Converted vm_page bit fields to flags to allow for some optimizations

diff --git a/sys/vm/device_pager.c b/sys/vm/device_pager.c
index 7dfe5c9..89f9a22 100644 (file)
--- a/sys/vm/device_pager.c
+++ b/sys/vm/device_pager.c
@@ -335,8 +335,6 @@ dev_pager_getfake(paddr)
 
        if (queue_empty(&dev_pager_fakelist)) {
                m = (vm_page_t)malloc(PAGE_SIZE, M_VMPGDATA, M_WAITOK);
 
        if (queue_empty(&dev_pager_fakelist)) {
                m = (vm_page_t)malloc(PAGE_SIZE, M_VMPGDATA, M_WAITOK);

-               /* bzero isn't really necessary, but we're being extra tidy */
-               bzero((caddr_t)m, PAGE_SIZE);

                for (i = PAGE_SIZE / sizeof(*m); i > 0; i--) {
                        queue_enter(&dev_pager_fakelist, m, vm_page_t, pageq);
                        m++;
                for (i = PAGE_SIZE / sizeof(*m); i > 0; i--) {
                        queue_enter(&dev_pager_fakelist, m, vm_page_t, pageq);
                        m++;


@@ -344,14 +342,8 @@ dev_pager_getfake(paddr)
        }
        queue_remove_first(&dev_pager_fakelist, m, vm_page_t, pageq);
 
        }
        queue_remove_first(&dev_pager_fakelist, m, vm_page_t, pageq);
 

-       /* Initialize all fields to zero */
-       bzero((caddr_t)m, sizeof(*m));
-
-#if 0

        m->flags = PG_BUSY | PG_CLEAN | PG_FAKE | PG_FICTITIOUS;
        m->flags = PG_BUSY | PG_CLEAN | PG_FAKE | PG_FICTITIOUS;

-#endif

 
 

-       m->busy = m->clean = m->fake = m->fictitious = TRUE;

        m->wire_count = 1;
        m->phys_addr = paddr;
 
        m->wire_count = 1;
        m->phys_addr = paddr;
 


@@ -363,10 +355,7 @@ dev_pager_putfake(m)
        vm_page_t m;
 {
 #ifdef DIAGNOSTIC
        vm_page_t m;
 {
 #ifdef DIAGNOSTIC

-#if 0

        if (!(m->flags & PG_FICTITIOUS))
        if (!(m->flags & PG_FICTITIOUS))

-#endif
-       if (!m->ficticious)

                panic("dev_pager_putfake: bad page");
 #endif
        queue_enter(&dev_pager_fakelist, m, vm_page_t, pageq);
                panic("dev_pager_putfake: bad page");
 #endif
        queue_enter(&dev_pager_fakelist, m, vm_page_t, pageq);

diff --git a/sys/vm/swap_pager.c b/sys/vm/swap_pager.c
index 42d8792..136f5f8 100644 (file)
--- a/sys/vm/swap_pager.c
+++ b/sys/vm/swap_pager.c
@@ -37,7 +37,7 @@
  *
  *     from: Utah $Hdr: swap_pager.c 1.4 91/04/30$
  *     from: @(#)swap_pager.c  7.4 (Berkeley) 5/7/91
  *
  *     from: Utah $Hdr: swap_pager.c 1.4 91/04/30$
  *     from: @(#)swap_pager.c  7.4 (Berkeley) 5/7/91

- *     $Id: swap_pager.c,v 1.7 1993/12/19 00:55:56 wollman Exp $
+ *     $Id: swap_pager.c,v 1.8 1993/12/19 23:24:15 wollman Exp $

  */
 
 /*
  */
 
 /*


@@ -684,7 +684,7 @@ swap_pager_io(swp, m, flags)
                thread_wakeup((int)&bswlist);
        }
        if ((flags & B_READ) == 0 && rv == VM_PAGER_OK) {
                thread_wakeup((int)&bswlist);
        }
        if ((flags & B_READ) == 0 && rv == VM_PAGER_OK) {

-               m->clean = TRUE;
+               m->flags |= PG_CLEAN;

                pmap_clear_modify(VM_PAGE_TO_PHYS(m));
        }
        splx(s);
                pmap_clear_modify(VM_PAGE_TO_PHYS(m));
        }
        splx(s);


@@ -822,7 +822,7 @@ swap_pager_finish(spc)
                if (swpagerdebug & SDB_ANOM)
                        printf("swap_pager_finish: page %x dirty again\n",
                               spc->spc_m);
                if (swpagerdebug & SDB_ANOM)
                        printf("swap_pager_finish: page %x dirty again\n",
                               spc->spc_m);

-               spc->spc_m->busy = FALSE;
+               spc->spc_m->flags &= ~PG_BUSY;

                PAGE_WAKEUP(spc->spc_m);
                vm_object_unlock(object);
                return(1);
                PAGE_WAKEUP(spc->spc_m);
                vm_object_unlock(object);
                return(1);


@@ -836,12 +836,12 @@ swap_pager_finish(spc)
        if (spc->spc_flags & SPC_ERROR) {
                printf("swap_pager_finish: clean of page %x failed\n",
                       VM_PAGE_TO_PHYS(spc->spc_m));
        if (spc->spc_flags & SPC_ERROR) {
                printf("swap_pager_finish: clean of page %x failed\n",
                       VM_PAGE_TO_PHYS(spc->spc_m));

-               spc->spc_m->laundry = TRUE;
+               spc->spc_m->flags |= PG_LAUNDRY;

        } else {
        } else {

-               spc->spc_m->clean = TRUE;
+               spc->spc_m->flags |= PG_CLEAN;

                pmap_clear_modify(VM_PAGE_TO_PHYS(spc->spc_m));
        }
                pmap_clear_modify(VM_PAGE_TO_PHYS(spc->spc_m));
        }

-       spc->spc_m->busy = FALSE;
+       spc->spc_m->flags &= ~PG_BUSY;

        PAGE_WAKEUP(spc->spc_m);
 
        vm_object_unlock(object);
        PAGE_WAKEUP(spc->spc_m);
 
        vm_object_unlock(object);

diff --git a/sys/vm/vm_fault.c b/sys/vm/vm_fault.c
index e5e3ac6..e120f28 100644 (file)
--- a/sys/vm/vm_fault.c
+++ b/sys/vm/vm_fault.c
@@ -34,7 +34,7 @@
  * SUCH DAMAGE.
  *
  *     from: @(#)vm_fault.c    7.6 (Berkeley) 5/7/91
  * SUCH DAMAGE.
  *
  *     from: @(#)vm_fault.c    7.6 (Berkeley) 5/7/91

- *     $Id: vm_fault.c,v 1.8 1993/12/12 12:27:22 davidg Exp $
+ *     $Id: vm_fault.c,v 1.9 1993/12/19 00:55:59 wollman Exp $

  */
 
 /*
  */
 
 /*


@@ -246,7 +246,7 @@ vm_fault(map, vaddr, fault_type, change_wiring)
                         *      If the page is being brought in,
                         *      wait for it and then retry.
                         */
                         *      If the page is being brought in,
                         *      wait for it and then retry.
                         */

-                       if (m->busy) {
+                       if (m->flags & PG_BUSY) {

 #ifdef DOTHREADS
                                int     wait_result;
 
 #ifdef DOTHREADS
                                int     wait_result;
 


@@ -268,62 +268,27 @@ vm_fault(map, vaddr, fault_type, change_wiring)
 #endif
                        }
 
 #endif
                        }
 

-                       if (m->absent)
+                       if (m->flags & PG_ABSENT)

                                panic("vm_fault: absent");
 
                                panic("vm_fault: absent");
 

-                       /*
-                        *      If the desired access to this page has
-                        *      been locked out, request that it be unlocked.
-                        */
-
-#ifdef PAGER_PAGE_LOCKING
-                       if (fault_type & m->page_lock) {
-#ifdef DOTHREADS
-                               int     wait_result;
-
-                               if ((fault_type & m->unlock_request) != fault_type)
-                                       panic("vm_fault: pager_data_unlock");
-
-                               PAGE_ASSERT_WAIT(m, !change_wiring);
-                               UNLOCK_THINGS;
-                               thread_block("pgunlck");
-                               wait_result = current_thread()->wait_result;
-                               vm_object_deallocate(first_object);
-                               if (wait_result != THREAD_AWAKENED)
-                                       return(KERN_SUCCESS);
-                               goto RetryFault;
-#else
-                               if ((fault_type & m->unlock_request) != fault_type)
-                                       panic("vm_fault: pager_data_unlock");
-
-                               PAGE_ASSERT_WAIT(m, !change_wiring);
-                               UNLOCK_THINGS;
-                               thread_wakeup((int)&vm_pages_needed); /* XXX */
-                               thread_block("pgunlck");
-                               vm_object_deallocate(first_object);
-                               goto RetryFault;
-#endif
-                       }
-#endif
-

                        /*
                         *      Remove the page from the pageout daemon's
                         *      reach while we play with it.
                         */
 
                        vm_page_lock_queues();
                        /*
                         *      Remove the page from the pageout daemon's
                         *      reach while we play with it.
                         */
 
                        vm_page_lock_queues();

-                       if (m->inactive) {
+                       if (m->flags & PG_INACTIVE) {

                                queue_remove(&vm_page_queue_inactive, m,
                                                vm_page_t, pageq);
                                queue_remove(&vm_page_queue_inactive, m,
                                                vm_page_t, pageq);

-                               m->inactive = FALSE;
+                               m->flags &= ~PG_INACTIVE;

                                vm_page_inactive_count--;
                                vm_stat.reactivations++;
                        } 
 
                                vm_page_inactive_count--;
                                vm_stat.reactivations++;
                        } 
 

-                       if (m->active) {
+                       if (m->flags & PG_ACTIVE) {

                                queue_remove(&vm_page_queue_active, m,
                                                vm_page_t, pageq);
                                queue_remove(&vm_page_queue_active, m,
                                                vm_page_t, pageq);

-                               m->active = FALSE;
+                               m->flags &= ~PG_ACTIVE;

                                vm_page_active_count--;
                        }
                        vm_page_unlock_queues();
                                vm_page_active_count--;
                        }
                        vm_page_unlock_queues();


@@ -331,8 +296,8 @@ vm_fault(map, vaddr, fault_type, change_wiring)
                        /*
                         *      Mark page busy for other threads.
                         */
                        /*
                         *      Mark page busy for other threads.
                         */

-                       m->busy = TRUE;
-                       m->absent = FALSE;
+                       m->flags |= PG_BUSY;
+                       m->flags &= ~PG_ABSENT;

                        break;
                }
 
                        break;
                }
 


@@ -386,7 +351,7 @@ vm_fault(map, vaddr, fault_type, change_wiring)
                                m = vm_page_lookup(object, offset);
 
                                vm_stat.pageins++;
                                m = vm_page_lookup(object, offset);
 
                                vm_stat.pageins++;

-                               m->fake = FALSE;
+                               m->flags &= ~PG_FAKE;

                                pmap_clear_modify(VM_PAGE_TO_PHYS(m));
                                break;
                        }
                                pmap_clear_modify(VM_PAGE_TO_PHYS(m));
                                break;
                        }


@@ -457,8 +422,7 @@ vm_fault(map, vaddr, fault_type, change_wiring)
 
                        vm_page_zero_fill(m);
                        vm_stat.zero_fill_count++;
 
                        vm_page_zero_fill(m);
                        vm_stat.zero_fill_count++;

-                       m->fake = FALSE;
-                       m->absent = FALSE;
+                       m->flags &= ~(PG_FAKE | PG_ABSENT);

                        break;
                }
                else {
                        break;
                }
                else {


@@ -471,7 +435,7 @@ vm_fault(map, vaddr, fault_type, change_wiring)
                }
        }
 
                }
        }
 

-       if (m->absent || m->active || m->inactive || !m->busy)
+       if ((m->flags & (PG_ABSENT|PG_ACTIVE|PG_INACTIVE)) || !(m->flags & PG_BUSY))

                panic("vm_fault: absent or active or inactive or not busy after main loop");
 
        /*
                panic("vm_fault: absent or active or inactive or not busy after main loop");
 
        /*


@@ -519,8 +483,7 @@ vm_fault(map, vaddr, fault_type, change_wiring)
                         */
 
                        vm_page_copy(m, first_m);
                         */
 
                        vm_page_copy(m, first_m);

-                       first_m->fake = FALSE;
-                       first_m->absent = FALSE;
+                       first_m->flags &= ~(PG_FAKE | PG_ABSENT);

 
                        /*
                         *      If another map is truly sharing this
 
                        /*
                         *      If another map is truly sharing this


@@ -572,11 +535,11 @@ vm_fault(map, vaddr, fault_type, change_wiring)
                }
                else {
                        prot &= (~VM_PROT_WRITE);
                }
                else {
                        prot &= (~VM_PROT_WRITE);

-                       m->copy_on_write = TRUE;
+                       m->flags |= PG_COPY_ON_WRITE;

                }
        }
 
                }
        }
 

-       if (m->active || m->inactive)
+       if (m->flags & (PG_ACTIVE|PG_INACTIVE))

                panic("vm_fault: active or inactive before copy object handling");
 
        /*
                panic("vm_fault: active or inactive before copy object handling");
 
        /*


@@ -594,7 +557,7 @@ vm_fault(map, vaddr, fault_type, change_wiring)
                 */
                if ((fault_type & VM_PROT_WRITE) == 0) {
                        prot &= ~VM_PROT_WRITE;
                 */
                if ((fault_type & VM_PROT_WRITE) == 0) {
                        prot &= ~VM_PROT_WRITE;

-                       m->copy_on_write = TRUE;
+                       m->flags |= PG_COPY_ON_WRITE;

                }
                else {
                        /*
                }
                else {
                        /*


@@ -621,7 +584,7 @@ vm_fault(map, vaddr, fault_type, change_wiring)
                                - copy_object->shadow_offset;
                        copy_m = vm_page_lookup(copy_object, copy_offset);
                        if (page_exists = (copy_m != NULL)) {
                                - copy_object->shadow_offset;
                        copy_m = vm_page_lookup(copy_object, copy_offset);
                        if (page_exists = (copy_m != NULL)) {

-                               if (copy_m->busy) {
+                               if (copy_m->flags & PG_BUSY) {

 #ifdef DOTHREADS
                                        int     wait_result;
 
 #ifdef DOTHREADS
                                        int     wait_result;
 


@@ -739,8 +702,7 @@ vm_fault(map, vaddr, fault_type, change_wiring)
                                 *      Must copy page into copy-object.
                                 */
                                vm_page_copy(m, copy_m);
                                 *      Must copy page into copy-object.
                                 */
                                vm_page_copy(m, copy_m);

-                               copy_m->fake = FALSE;
-                               copy_m->absent = FALSE;
+                               copy_m->flags &= ~(PG_FAKE|PG_ABSENT);

 
                                /*
                                 * Things to remember:
 
                                /*
                                 * Things to remember:


@@ -755,7 +717,7 @@ vm_fault(map, vaddr, fault_type, change_wiring)
                                vm_page_lock_queues();
                                pmap_page_protect(VM_PAGE_TO_PHYS(old_m),
                                                  VM_PROT_NONE);
                                vm_page_lock_queues();
                                pmap_page_protect(VM_PAGE_TO_PHYS(old_m),
                                                  VM_PROT_NONE);

-                               copy_m->clean = FALSE;
+                               copy_m->flags &= ~PG_CLEAN;

                                vm_page_activate(copy_m);       /* XXX */
                                vm_page_unlock_queues();
 
                                vm_page_activate(copy_m);       /* XXX */
                                vm_page_unlock_queues();
 


@@ -770,11 +732,11 @@ vm_fault(map, vaddr, fault_type, change_wiring)
                         */
                        copy_object->ref_count--;
                        vm_object_unlock(copy_object);
                         */
                        copy_object->ref_count--;
                        vm_object_unlock(copy_object);

-                       m->copy_on_write = FALSE;
+                       m->flags &= ~PG_COPY_ON_WRITE;

                }
        }
 
                }
        }
 

-       if (m->active || m->inactive)
+       if (m->flags & (PG_ACTIVE|PG_INACTIVE))

                panic("vm_fault: active or inactive before retrying lookup");
 
        /*
                panic("vm_fault: active or inactive before retrying lookup");
 
        /*


@@ -839,7 +801,7 @@ vm_fault(map, vaddr, fault_type, change_wiring)
                 *      can't mark the page write-enabled after all.
                 */
                prot &= retry_prot;
                 *      can't mark the page write-enabled after all.
                 */
                prot &= retry_prot;

-               if (m->copy_on_write)
+               if (m->flags & PG_COPY_ON_WRITE)

                        prot &= ~VM_PROT_WRITE;
        }
 
                        prot &= ~VM_PROT_WRITE;
        }
 


@@ -851,14 +813,14 @@ vm_fault(map, vaddr, fault_type, change_wiring)
        /* XXX This distorts the meaning of the copy_on_write bit */
 
        if (prot & VM_PROT_WRITE)
        /* XXX This distorts the meaning of the copy_on_write bit */
 
        if (prot & VM_PROT_WRITE)

-               m->copy_on_write = FALSE;
+               m->flags &= ~PG_COPY_ON_WRITE;

 
        /*
         *      It's critically important that a wired-down page be faulted
         *      only once in each map for which it is wired.
         */
 
 
        /*
         *      It's critically important that a wired-down page be faulted
         *      only once in each map for which it is wired.
         */
 

-       if (m->active || m->inactive)
+       if (m->flags & (PG_ACTIVE|PG_INACTIVE))

                panic("vm_fault: active or inactive before pmap_enter");
 
        vm_object_unlock(object);
                panic("vm_fault: active or inactive before pmap_enter");
 
        vm_object_unlock(object);


@@ -870,13 +832,7 @@ vm_fault(map, vaddr, fault_type, change_wiring)
         *      page back on the active queue until later so
         *      that the page-out daemon won't find us (yet).
         */
         *      page back on the active queue until later so
         *      that the page-out daemon won't find us (yet).
         */

-
-#ifdef PAGER_PAGE_LOCKING
-       pmap_enter(map->pmap, vaddr, VM_PAGE_TO_PHYS(m), 
-                       prot & ~(m->page_lock), wired);
-#else

        pmap_enter(map->pmap, vaddr, VM_PAGE_TO_PHYS(m), prot, wired);
        pmap_enter(map->pmap, vaddr, VM_PAGE_TO_PHYS(m), prot, wired);

-#endif

 
        /*
         *      If the page is not wired down, then put it where the
 
        /*
         *      If the page is not wired down, then put it where the

diff --git a/sys/vm/vm_kern.c b/sys/vm/vm_kern.c
index 5c3bae6..0341a97 100644 (file)
--- a/sys/vm/vm_kern.c
+++ b/sys/vm/vm_kern.c
@@ -34,7 +34,7 @@
  * SUCH DAMAGE.
  *
  *     from: @(#)vm_kern.c     7.4 (Berkeley) 5/7/91
  * SUCH DAMAGE.
  *
  *     from: @(#)vm_kern.c     7.4 (Berkeley) 5/7/91

- *     $Id: vm_kern.c,v 1.5 1993/11/25 01:39:02 wollman Exp $
+ *     $Id: vm_kern.c,v 1.6 1993/12/19 00:56:01 wollman Exp $

  */
 
 /*
  */
 
 /*


@@ -194,7 +194,7 @@ vm_offset_t kmem_alloc(map, size)
                        vm_object_lock(kernel_object);
                }
                vm_page_zero_fill(mem);
                        vm_object_lock(kernel_object);
                }
                vm_page_zero_fill(mem);

-               mem->busy = FALSE;
+               mem->flags &= ~PG_BUSY;

        }
        vm_object_unlock(kernel_object);
                
        }
        vm_object_unlock(kernel_object);
                


@@ -443,7 +443,7 @@ kmem_malloc(map, size, canwait)
 #if 0
                vm_page_zero_fill(m);
 #endif
 #if 0
                vm_page_zero_fill(m);
 #endif

-               m->busy = FALSE;
+               m->flags &= ~PG_BUSY;

        }
        vm_object_unlock(kmem_object);
 
        }
        vm_object_unlock(kmem_object);
 

diff --git a/sys/vm/vm_object.c b/sys/vm/vm_object.c
index 8be0b4e..cb258a9 100644 (file)
--- a/sys/vm/vm_object.c
+++ b/sys/vm/vm_object.c
@@ -34,7 +34,7 @@
  * SUCH DAMAGE.
  *
  *     from: @(#)vm_object.c   7.4 (Berkeley) 5/7/91
  * SUCH DAMAGE.
  *
  *     from: @(#)vm_object.c   7.4 (Berkeley) 5/7/91

- *     $Id: vm_object.c,v 1.10 1993/11/25 12:07:41 davidg Exp $
+ *     $Id: vm_object.c,v 1.11 1993/12/19 00:56:07 wollman Exp $

  */
 
 /*
  */
 
 /*


@@ -284,7 +284,7 @@ void vm_object_deallocate(object)
                                VM_PAGE_CHECK(p);
 
                                if (pmap_is_modified(VM_PAGE_TO_PHYS(p)) ||
                                VM_PAGE_CHECK(p);
 
                                if (pmap_is_modified(VM_PAGE_TO_PHYS(p)) ||

-                                                               !p->clean) {
+                                                               !(p->flags & PG_CLEAN)) {

 
                                        printf("vm_object_dealloc: persistent object %x isn't clean\n", object);
                                        goto cant_persist;
 
                                        printf("vm_object_dealloc: persistent object %x isn't clean\n", object);
                                        goto cant_persist;


@@ -376,17 +376,17 @@ void vm_object_terminate(object)
                VM_PAGE_CHECK(p);
 
                vm_page_lock_queues();
                VM_PAGE_CHECK(p);
 
                vm_page_lock_queues();

-               if (p->active) {
+               if (p->flags & PG_ACTIVE) {

                        queue_remove(&vm_page_queue_active, p, vm_page_t,
                                                pageq);
                        queue_remove(&vm_page_queue_active, p, vm_page_t,
                                                pageq);

-                       p->active = FALSE;
+                       p->flags &= ~PG_ACTIVE;

                        vm_page_active_count--;
                }
 
                        vm_page_active_count--;
                }
 

-               if (p->inactive) {
+               if (p->flags & PG_INACTIVE) {

                        queue_remove(&vm_page_queue_inactive, p, vm_page_t,
                                                pageq);
                        queue_remove(&vm_page_queue_inactive, p, vm_page_t,
                                                pageq);

-                       p->inactive = FALSE;
+                       p->flags &= ~PG_INACTIVE;

                        vm_page_inactive_count--;
                }
                vm_page_unlock_queues();
                        vm_page_inactive_count--;
                }
                vm_page_unlock_queues();


@@ -465,17 +465,17 @@ again:
        while (!queue_end(&object->memq, (queue_entry_t) p)) {
                if (start == end ||
                    p->offset >= start && p->offset < end) {
        while (!queue_end(&object->memq, (queue_entry_t) p)) {
                if (start == end ||
                    p->offset >= start && p->offset < end) {

-                       if (p->clean && pmap_is_modified(VM_PAGE_TO_PHYS(p)))
-                               p->clean = FALSE;
+                       if ((p->flags & PG_CLEAN) && pmap_is_modified(VM_PAGE_TO_PHYS(p)))
+                               p->flags &= ~PG_CLEAN;

                        pmap_page_protect(VM_PAGE_TO_PHYS(p), VM_PROT_NONE);
                        pmap_page_protect(VM_PAGE_TO_PHYS(p), VM_PROT_NONE);

-                       if (!p->clean) {
-                               p->busy = TRUE;
+                       if (!(p->flags & PG_CLEAN)) {
+                               p->flags |= PG_BUSY;

                                object->paging_in_progress++;
                                vm_object_unlock(object);
                                (void) vm_pager_put(object->pager, p, TRUE);
                                vm_object_lock(object);
                                object->paging_in_progress--;
                                object->paging_in_progress++;
                                vm_object_unlock(object);
                                (void) vm_pager_put(object->pager, p, TRUE);
                                vm_object_lock(object);
                                object->paging_in_progress--;

-                               p->busy = FALSE;
+                               p->flags &= ~PG_BUSY;

                                PAGE_WAKEUP(p);
                                goto again;
                        }
                                PAGE_WAKEUP(p);
                                goto again;
                        }


@@ -502,7 +502,7 @@ vm_object_deactivate_pages(object)
        while (!queue_end(&object->memq, (queue_entry_t) p)) {
                next = (vm_page_t) queue_next(&p->listq);
                vm_page_lock_queues();
        while (!queue_end(&object->memq, (queue_entry_t) p)) {
                next = (vm_page_t) queue_next(&p->listq);
                vm_page_lock_queues();

-               if (!p->busy)
+               if (!(p->flags & PG_BUSY))

                        vm_page_deactivate(p);  /* optimisation from mach 3.0 -
                                                 * andrew@werple.apana.org.au,
                                                 * Feb '93
                        vm_page_deactivate(p);  /* optimisation from mach 3.0 -
                                                 * andrew@werple.apana.org.au,
                                                 * Feb '93


@@ -615,7 +615,7 @@ void vm_object_pmap_copy(object, start, end)
        while (!queue_end(&object->memq, (queue_entry_t) p)) {
                if ((start <= p->offset) && (p->offset < end)) {
                        pmap_page_protect(VM_PAGE_TO_PHYS(p), VM_PROT_READ);
        while (!queue_end(&object->memq, (queue_entry_t) p)) {
                if ((start <= p->offset) && (p->offset < end)) {
                        pmap_page_protect(VM_PAGE_TO_PHYS(p), VM_PROT_READ);

-                       p->copy_on_write = TRUE;
+                       p->flags |= PG_COPY_ON_WRITE;

                }
                p = (vm_page_t) queue_next(&p->listq);
        }
                }
                p = (vm_page_t) queue_next(&p->listq);
        }


@@ -718,7 +718,7 @@ void vm_object_copy(src_object, src_offset, size,
                     p = (vm_page_t) queue_next(&p->listq)) {
                        if (src_offset <= p->offset &&
                            p->offset < src_offset + size)
                     p = (vm_page_t) queue_next(&p->listq)) {
                        if (src_offset <= p->offset &&
                            p->offset < src_offset + size)

-                               p->copy_on_write = TRUE;
+                               p->flags |= PG_COPY_ON_WRITE;

                }
                vm_object_unlock(src_object);
 
                }
                vm_object_unlock(src_object);
 


@@ -847,7 +847,7 @@ void vm_object_copy(src_object, src_offset, size,
        p = (vm_page_t) queue_first(&src_object->memq);
        while (!queue_end(&src_object->memq, (queue_entry_t) p)) {
                if ((new_start <= p->offset) && (p->offset < new_end))
        p = (vm_page_t) queue_first(&src_object->memq);
        while (!queue_end(&src_object->memq, (queue_entry_t) p)) {
                if ((new_start <= p->offset) && (p->offset < new_end))

-                       p->copy_on_write = TRUE;
+                       p->flags |= PG_COPY_ON_WRITE;

                p = (vm_page_t) queue_next(&p->listq);
        }
 
                p = (vm_page_t) queue_next(&p->listq);
        }
 


@@ -1196,7 +1196,7 @@ void vm_object_collapse(object)
                                        vm_page_unlock_queues();
                                } else {
                                    pp = vm_page_lookup(object, new_offset);
                                        vm_page_unlock_queues();
                                } else {
                                    pp = vm_page_lookup(object, new_offset);

-                                   if (pp != NULL && !pp->fake) {
+                                   if (pp != NULL && !(pp->flags & PG_FAKE)) {

                                        vm_page_lock_queues();
                                        vm_page_free(p);
                                        vm_page_unlock_queues();
                                        vm_page_lock_queues();
                                        vm_page_free(p);
                                        vm_page_unlock_queues();


@@ -1348,7 +1348,7 @@ void vm_object_collapse(object)
                                    new_offset <= size &&
                                    ((pp = vm_page_lookup(object, new_offset))
                                      == NULL ||
                                    new_offset <= size &&
                                    ((pp = vm_page_lookup(object, new_offset))
                                      == NULL ||

-                                    pp->fake)) {
+                                    (pp->flags & PG_FAKE))) {

                                        /*
                                         *      Page still needed.
                                         *      Can't go any further.
                                        /*
                                         *      Page still needed.
                                         *      Can't go any further.

diff --git a/sys/vm/vm_page.c b/sys/vm/vm_page.c
index fd24784..a86ed5d 100644 (file)
--- a/sys/vm/vm_page.c
+++ b/sys/vm/vm_page.c
@@ -34,7 +34,7 @@
  * SUCH DAMAGE.
  *
  *     from: @(#)vm_page.c     7.4 (Berkeley) 5/7/91
  * SUCH DAMAGE.
  *
  *     from: @(#)vm_page.c     7.4 (Berkeley) 5/7/91

- *     $Id: vm_page.c,v 1.4 1993/12/12 12:27:24 davidg Exp $
+ *     $Id: vm_page.c,v 1.5 1993/12/19 00:56:10 wollman Exp $

  */
 
 /*
  */
 
 /*


@@ -290,12 +290,6 @@ vm_offset_t vm_page_startup(start, end, vaddr)
 
        pa = first_phys_addr;
        while (npages--) {
 
        pa = first_phys_addr;
        while (npages--) {

-               m->copy_on_write = FALSE;
-               m->wanted = FALSE;
-               m->inactive = FALSE;
-               m->active = FALSE;
-               m->busy = FALSE;
-               m->object = NULL;

                m->phys_addr = pa;
                queue_enter(&vm_page_queue_free, m, vm_page_t, pageq);
                m++;
                m->phys_addr = pa;
                queue_enter(&vm_page_queue_free, m, vm_page_t, pageq);
                m++;


@@ -340,7 +334,7 @@ void vm_page_insert(mem, object, offset)
 
        VM_PAGE_CHECK(mem);
 
 
        VM_PAGE_CHECK(mem);
 

-       if (mem->tabled)
+       if (mem->flags & PG_TABLED)

                panic("vm_page_insert: already inserted");
 
        /*
                panic("vm_page_insert: already inserted");
 
        /*


@@ -366,7 +360,7 @@ void vm_page_insert(mem, object, offset)
         */
 
        queue_enter(&object->memq, mem, vm_page_t, listq);
         */
 
        queue_enter(&object->memq, mem, vm_page_t, listq);

-       mem->tabled = TRUE;
+       mem->flags |= PG_TABLED;

 
        /*
         *      And show that the object has one more resident
 
        /*
         *      And show that the object has one more resident


@@ -393,7 +387,7 @@ void vm_page_remove(mem)
 
        VM_PAGE_CHECK(mem);
 
 
        VM_PAGE_CHECK(mem);
 

-       if (!mem->tabled)
+       if (!(mem->flags & PG_TABLED))

                return;
 
        /*
                return;
 
        /*


@@ -420,7 +414,7 @@ void vm_page_remove(mem)
 
        mem->object->resident_page_count--;
 
 
        mem->object->resident_page_count--;
 

-       mem->tabled = FALSE;
+       mem->flags &= ~PG_TABLED;

 }
 
 /*
 }
 
 /*


@@ -487,35 +481,6 @@ void vm_page_rename(mem, new_object, new_offset)
        vm_page_unlock_queues();
 }
 
        vm_page_unlock_queues();
 }
 

-void
-vm_page_init(mem, object, offset)
-       vm_page_t       mem;
-       vm_object_t     object;
-       vm_offset_t     offset;
-{
-               mem->busy = TRUE;
-               mem->tabled = FALSE;
-               vm_page_insert(mem, object, offset);
-               mem->absent = FALSE;
-               mem->fictitious = FALSE;
-#ifdef PAGER_PAGE_LOCKING
-               mem->page_lock = VM_PROT_NONE;
-               mem->unlock_request = VM_PROT_NONE;
-#endif
-               mem->laundry = FALSE;
-               mem->active = FALSE;
-               mem->inactive = FALSE;
-               mem->wire_count = 0;
-               mem->clean = TRUE;
-               mem->copy_on_write = FALSE;
-               mem->fake = TRUE;
-#ifdef DEBUG
-               mem->pagerowned = FALSE;
-               mem->ptpage = FALSE;
-#endif
-
-}
-

 /*
  *     vm_page_alloc:
  *
 /*
  *     vm_page_alloc:
  *


@@ -553,7 +518,9 @@ vm_page_t vm_page_alloc(object, offset)
        simple_unlock(&vm_page_queue_free_lock);
        splx(spl);
 
        simple_unlock(&vm_page_queue_free_lock);
        splx(spl);
 

-       vm_page_init(mem, object, offset);
+       mem->flags = PG_BUSY|PG_CLEAN|PG_FAKE;
+       vm_page_insert(mem, object, offset);
+       mem->wire_count = 0;

 
        /*
         *      Decide if we should poke the pageout daemon.
 
        /*
         *      Decide if we should poke the pageout daemon.


@@ -585,19 +552,19 @@ void vm_page_free(mem)
        register vm_page_t      mem;
 {
        vm_page_remove(mem);
        register vm_page_t      mem;
 {
        vm_page_remove(mem);

-       if (mem->active) {
+       if (mem->flags & PG_ACTIVE) {

                queue_remove(&vm_page_queue_active, mem, vm_page_t, pageq);
                queue_remove(&vm_page_queue_active, mem, vm_page_t, pageq);

-               mem->active = FALSE;
+               mem->flags &= ~PG_ACTIVE;

                vm_page_active_count--;
        }
 
                vm_page_active_count--;
        }
 

-       if (mem->inactive) {
+       if (mem->flags & PG_INACTIVE) {

                queue_remove(&vm_page_queue_inactive, mem, vm_page_t, pageq);
                queue_remove(&vm_page_queue_inactive, mem, vm_page_t, pageq);

-               mem->inactive = FALSE;
+               mem->flags &= ~PG_INACTIVE;

                vm_page_inactive_count--;
        }
 
                vm_page_inactive_count--;
        }
 

-       if (!mem->fictitious) {
+       if (!(mem->flags & PG_FICTITIOUS)) {

                int     spl;
 
                spl = splimp();
                int     spl;
 
                spl = splimp();


@@ -625,17 +592,17 @@ void vm_page_wire(mem)
        VM_PAGE_CHECK(mem);
 
        if (mem->wire_count == 0) {
        VM_PAGE_CHECK(mem);
 
        if (mem->wire_count == 0) {

-               if (mem->active) {
+               if (mem->flags & PG_ACTIVE) {

                        queue_remove(&vm_page_queue_active, mem, vm_page_t,
                                                pageq);
                        vm_page_active_count--;
                        queue_remove(&vm_page_queue_active, mem, vm_page_t,
                                                pageq);
                        vm_page_active_count--;

-                       mem->active = FALSE;
+                       mem->flags &= ~PG_ACTIVE;

                }
                }

-               if (mem->inactive) {
+               if (mem->flags & PG_INACTIVE) {

                        queue_remove(&vm_page_queue_inactive, mem, vm_page_t,
                                                pageq);
                        vm_page_inactive_count--;
                        queue_remove(&vm_page_queue_inactive, mem, vm_page_t,
                                                pageq);
                        vm_page_inactive_count--;

-                       mem->inactive = FALSE;
+                       mem->flags &= ~PG_INACTIVE;

                }
                vm_page_wire_count++;
        }
                }
                vm_page_wire_count++;
        }


@@ -659,7 +626,7 @@ void vm_page_unwire(mem)
        if (mem->wire_count == 0) {
                queue_enter(&vm_page_queue_active, mem, vm_page_t, pageq);
                vm_page_active_count++;
        if (mem->wire_count == 0) {
                queue_enter(&vm_page_queue_active, mem, vm_page_t, pageq);
                vm_page_active_count++;

-               mem->active = TRUE;
+               mem->flags |= PG_ACTIVE;

                vm_page_wire_count--;
        }
 }
                vm_page_wire_count--;
        }
 }


@@ -688,19 +655,22 @@ void vm_page_deactivate(m)
         *      Paul Mackerras (paulus@cs.anu.edu.au) 9-Jan-93.
         */
 
         *      Paul Mackerras (paulus@cs.anu.edu.au) 9-Jan-93.
         */
 

-       if (!m->inactive && m->wire_count == 0) {
+       if (!(m->flags & PG_INACTIVE) && m->wire_count == 0) {

                pmap_clear_reference(VM_PAGE_TO_PHYS(m));
                pmap_clear_reference(VM_PAGE_TO_PHYS(m));

-               if (m->active) {
+               if (m->flags & PG_ACTIVE) {

                        queue_remove(&vm_page_queue_active, m, vm_page_t, pageq);
                        queue_remove(&vm_page_queue_active, m, vm_page_t, pageq);

-                       m->active = FALSE;
+                       m->flags &= ~PG_ACTIVE;

                        vm_page_active_count--;
                }
                queue_enter(&vm_page_queue_inactive, m, vm_page_t, pageq);
                        vm_page_active_count--;
                }
                queue_enter(&vm_page_queue_inactive, m, vm_page_t, pageq);

-               m->inactive = TRUE;
+               m->flags |= PG_INACTIVE;

                vm_page_inactive_count++;
                if (pmap_is_modified(VM_PAGE_TO_PHYS(m)))
                vm_page_inactive_count++;
                if (pmap_is_modified(VM_PAGE_TO_PHYS(m)))

-                       m->clean = FALSE;
-               m->laundry = !m->clean;
+                       m->flags &= ~PG_CLEAN;
+               if (m->flags & PG_CLEAN)
+                       m->flags &= ~PG_LAUNDRY;
+               else
+                       m->flags |= PG_LAUNDRY;

        }
 }
 
        }
 }
 


@@ -717,18 +687,18 @@ void vm_page_activate(m)
 {
        VM_PAGE_CHECK(m);
 
 {
        VM_PAGE_CHECK(m);
 

-       if (m->inactive) {
+       if (m->flags & PG_INACTIVE) {

                queue_remove(&vm_page_queue_inactive, m, vm_page_t,
                                                pageq);
                vm_page_inactive_count--;
                queue_remove(&vm_page_queue_inactive, m, vm_page_t,
                                                pageq);
                vm_page_inactive_count--;

-               m->inactive = FALSE;
+               m->flags &= ~PG_INACTIVE;

        }
        if (m->wire_count == 0) {
        }
        if (m->wire_count == 0) {

-               if (m->active)
+               if (m->flags & PG_ACTIVE)

                        panic("vm_page_activate: already active");
 
                queue_enter(&vm_page_queue_active, m, vm_page_t, pageq);
                        panic("vm_page_activate: already active");
 
                queue_enter(&vm_page_queue_active, m, vm_page_t, pageq);

-               m->active = TRUE;
+               m->flags |= PG_ACTIVE;

                vm_page_active_count++;
        }
 }
                vm_page_active_count++;
        }
 }

diff --git a/sys/vm/vm_page.h b/sys/vm/vm_page.h
index 97032e1..919ed83 100644 (file)
--- a/sys/vm/vm_page.h
+++ b/sys/vm/vm_page.h
@@ -34,7 +34,7 @@
  * SUCH DAMAGE.
  *
  *     from: @(#)vm_page.h     7.3 (Berkeley) 4/21/91
  * SUCH DAMAGE.
  *
  *     from: @(#)vm_page.h     7.3 (Berkeley) 4/21/91

- *     $Id: vm_page.h,v 1.4 1993/12/12 12:27:25 davidg Exp $
+ *     $Id: vm_page.h,v 1.5 1993/12/19 00:56:11 wollman Exp $

  */
 
 /*
  */
 
 /*


@@ -96,45 +96,33 @@
  *     queues (P).
  */
 
  *     queues (P).
  */
 

+#define PG_INACTIVE            0x0001
+#define PG_ACTIVE              0x0002
+#define PG_LAUNDRY             0x0004
+#define PG_CLEAN               0x0008
+#define PG_BUSY                        0x0010
+#define PG_WANTED              0x0020
+#define PG_TABLED              0x0040
+#define PG_COPY_ON_WRITE       0x0080
+#define PG_FICTITIOUS          0x0100
+#define PG_ABSENT              0x0200
+#define PG_FAKE                        0x0400
+#define PG_PAGEROWNED          0x0800
+#define PG_PTPAGE              0x1000
+

 struct vm_page {
 struct vm_page {

-       queue_chain_t   pageq;          /* queue info for FIFO
-                                        * queue or free list (P) */
+       queue_chain_t   pageq;          /* queue info for FIFO */
+                                       /* queue or free list (P) */

        queue_chain_t   hashq;          /* hash table links (O)*/
        queue_chain_t   listq;          /* all pages in same object (O)*/
 
        vm_object_t     object;         /* which object am I in (O,P)*/
        vm_offset_t     offset;         /* offset into that object (O,P) */
 
        queue_chain_t   hashq;          /* hash table links (O)*/
        queue_chain_t   listq;          /* all pages in same object (O)*/
 
        vm_object_t     object;         /* which object am I in (O,P)*/
        vm_offset_t     offset;         /* offset into that object (O,P) */
 

-       unsigned int    wire_count:16,  /* how many wired down maps use me?
-                                          (P) */
-                       inactive:1,     /* page is in inactive list (P) */
-                       active:1,       /* page is in active list (P) */
-                       laundry:1,      /* page is being cleaned now (P)*/
-                       clean:1,        /* page has not been modified */
-                       busy:1,         /* page is in transit (O) */
-                       wanted:1,       /* someone is waiting for page (O) */
-                       tabled:1,       /* page is in VP table (O) */
-                       copy_on_write:1,/* page must be copied before being
-                                          changed (O) */
-                       fictitious:1,   /* physical page doesn't exist (O) */
-                       absent:1,       /* virtual page doesn't exist (O) */
-                       fake:1,         /* page is a placeholder for page-in
-                                          (O) */
-#ifdef DEBUG
-                       pagerowned:1,   /* async paging op in progress */
-                       ptpage:1,       /* is a user page table page */
-#endif
-                       :0;             /* (force to 'long' boundary) */
-#ifdef ns32000
-       int             pad;            /* extra space for ns32000 bit ops */
-#endif /* ns32000 */
+       unsigned int    wire_count;     /* how many wired down maps use me? */
+       unsigned int    flags;          /* bit encoded flags */

 
        vm_offset_t     phys_addr;      /* physical address of page */
 
        vm_offset_t     phys_addr;      /* physical address of page */

-
-#ifdef PAGER_PAGE_LOCKING
-       vm_prot_t       page_lock;      /* Uses prohibited by data manager */
-       vm_prot_t       unlock_request; /* Outstanding unlock request */
-#endif

 };
 
 typedef struct vm_page *vm_page_t;
 };
 
 typedef struct vm_page *vm_page_t;


@@ -143,7 +131,7 @@ typedef struct vm_page      *vm_page_t;
 #define        VM_PAGE_CHECK(mem) { \
                if ( (((unsigned int) mem) < ((unsigned int) &vm_page_array[0])) || \
                     (((unsigned int) mem) > ((unsigned int) &vm_page_array[last_page-first_page])) || \
 #define        VM_PAGE_CHECK(mem) { \
                if ( (((unsigned int) mem) < ((unsigned int) &vm_page_array[0])) || \
                     (((unsigned int) mem) > ((unsigned int) &vm_page_array[last_page-first_page])) || \

-                    (mem->active && mem->inactive) \
+                    ((mem->flags & PG_ACTIVE) && (mem->flags & PG_INACTIVE)) \

                    ) panic("vm_page_check: not valid!"); \
                }
 #else /* VM_PAGE_DEBUG */
                    ) panic("vm_page_check: not valid!"); \
                }
 #else /* VM_PAGE_DEBUG */


@@ -224,7 +212,6 @@ simple_lock_data_t  vm_page_queue_free_lock;
 vm_offset_t    vm_page_startup();
 vm_page_t      vm_page_lookup();
 vm_page_t      vm_page_alloc();
 vm_offset_t    vm_page_startup();
 vm_page_t      vm_page_lookup();
 vm_page_t      vm_page_alloc();

-void           vm_page_init();

 void           vm_page_free();
 void           vm_page_activate();
 void           vm_page_deactivate();
 void           vm_page_free();
 void           vm_page_activate();
 void           vm_page_deactivate();


@@ -244,14 +231,14 @@ void              vm_set_page_size();
  */
 
 #define PAGE_ASSERT_WAIT(m, interruptible)     { \
  */
 
 #define PAGE_ASSERT_WAIT(m, interruptible)     { \

-                               (m)->wanted = TRUE; \
+                               (m)->flags |= PG_WANTED; \

                                assert_wait((int) (m), (interruptible)); \
                        }
 
 #define PAGE_WAKEUP(m) { \
                                assert_wait((int) (m), (interruptible)); \
                        }
 
 #define PAGE_WAKEUP(m) { \

-                               (m)->busy = FALSE; \
-                               if ((m)->wanted) { \
-                                       (m)->wanted = FALSE; \
+                               (m)->flags &= ~PG_BUSY; \
+                               if ((m)->flags & PG_WANTED) { \
+                                       (m)->flags &= ~PG_WANTED; \

                                        thread_wakeup((int) (m)); \
                                } \
                        }
                                        thread_wakeup((int) (m)); \
                                } \
                        }


@@ -259,7 +246,7 @@ void                vm_set_page_size();
 #define        vm_page_lock_queues()   simple_lock(&vm_page_queue_lock)
 #define        vm_page_unlock_queues() simple_unlock(&vm_page_queue_lock)
 
 #define        vm_page_lock_queues()   simple_lock(&vm_page_queue_lock)
 #define        vm_page_unlock_queues() simple_unlock(&vm_page_queue_lock)
 

-#define vm_page_set_modified(m)        { (m)->clean = FALSE; }
+#define vm_page_set_modified(m)        { (m)->flags &= ~PG_CLEAN; }

 
 /* Some pmap things are declared here for the convenience of other bits of
    code. */
 
 /* Some pmap things are declared here for the convenience of other bits of
    code. */

diff --git a/sys/vm/vm_pageout.c b/sys/vm/vm_pageout.c
index 8501cab..e0620db 100644 (file)
--- a/sys/vm/vm_pageout.c
+++ b/sys/vm/vm_pageout.c
@@ -34,7 +34,7 @@
  * SUCH DAMAGE.
  *
  *     from: @(#)vm_pageout.c  7.4 (Berkeley) 5/7/91
  * SUCH DAMAGE.
  *
  *     from: @(#)vm_pageout.c  7.4 (Berkeley) 5/7/91

- *     $Id: vm_pageout.c,v 1.6 1993/11/25 12:07:42 davidg Exp $
+ *     $Id: vm_pageout.c,v 1.7 1993/12/19 00:56:12 wollman Exp $

  */
 
 /*
  */
 
 /*


@@ -146,7 +146,7 @@ vm_pageout_scan()
                if (free >= vm_page_free_target)
                        break;
 
                if (free >= vm_page_free_target)
                        break;
 

-               if (m->clean) {
+               if (m->flags & PG_CLEAN) {

                        next = (vm_page_t) queue_next(&m->pageq);
                        if (pmap_is_referenced(VM_PAGE_TO_PHYS(m))) {
                                vm_page_activate(m);
                        next = (vm_page_t) queue_next(&m->pageq);
                        if (pmap_is_referenced(VM_PAGE_TO_PHYS(m))) {
                                vm_page_activate(m);


@@ -180,7 +180,7 @@ vm_pageout_scan()
                         *      cleaning operation.
                         */
 
                         *      cleaning operation.
                         */
 

-                       if (m->laundry) {
+                       if (m->flags & PG_LAUNDRY) {

                                /*
                                 *      Clean the page and remove it from the
                                 *      laundry.
                                /*
                                 *      Clean the page and remove it from the
                                 *      laundry.


@@ -253,7 +253,7 @@ vm_pageout_scan()
 
                                pmap_page_protect(VM_PAGE_TO_PHYS(m),
                                                  VM_PROT_NONE);
 
                                pmap_page_protect(VM_PAGE_TO_PHYS(m),
                                                  VM_PROT_NONE);

-                               m->busy = TRUE;
+                               m->flags |= PG_BUSY;

                                vm_stat.pageouts++;
 
                                object->paging_in_progress++;
                                vm_stat.pageouts++;
 
                                object->paging_in_progress++;


@@ -295,7 +295,7 @@ vm_pageout_scan()
                                switch (pageout_status) {
                                case VM_PAGER_OK:
                                case VM_PAGER_PEND:
                                switch (pageout_status) {
                                case VM_PAGER_OK:
                                case VM_PAGER_PEND:

-                                       m->laundry = FALSE;
+                                       m->flags &= ~PG_LAUNDRY;

                                        break;
                                case VM_PAGER_BAD:
                                        /*
                                        break;
                                case VM_PAGER_BAD:
                                        /*


@@ -304,8 +304,8 @@ vm_pageout_scan()
                                         * changes by pretending it worked.
                                         * XXX dubious, what should we do?
                                         */
                                         * changes by pretending it worked.
                                         * XXX dubious, what should we do?
                                         */

-                                       m->laundry = FALSE;
-                                       m->clean = TRUE;
+                                       m->flags &= ~PG_LAUNDRY;
+                                       m->flags |= PG_CLEAN;

                                        pmap_clear_modify(VM_PAGE_TO_PHYS(m));
                                        break;
                                case VM_PAGER_FAIL:
                                        pmap_clear_modify(VM_PAGE_TO_PHYS(m));
                                        break;
                                case VM_PAGER_FAIL:


@@ -329,7 +329,7 @@ vm_pageout_scan()
                                 * object collapse.
                                 */
                                if (pageout_status != VM_PAGER_PEND) {
                                 * object collapse.
                                 */
                                if (pageout_status != VM_PAGER_PEND) {

-                                       m->busy = FALSE;
+                                       m->flags &= ~PG_BUSY;

                                        PAGE_WAKEUP(m);
                                        object->paging_in_progress--;
                                }
                                        PAGE_WAKEUP(m);
                                        object->paging_in_progress--;
                                }

diff --git a/sys/vm/vm_pager.c b/sys/vm/vm_pager.c
index ef7983e..c23b001 100644 (file)
--- a/sys/vm/vm_pager.c
+++ b/sys/vm/vm_pager.c
@@ -34,7 +34,7 @@
  * SUCH DAMAGE.
  *
  *     from: @(#)vm_pager.c    7.4 (Berkeley) 5/7/91
  * SUCH DAMAGE.
  *
  *     from: @(#)vm_pager.c    7.4 (Berkeley) 5/7/91

- *     $Id: vm_pager.c,v 1.6 1993/12/19 00:56:13 wollman Exp $
+ *     $Id: vm_pager.c,v 1.7 1993/12/19 23:24:17 wollman Exp $

  */
 
 /*
  */
 
 /*


@@ -200,14 +200,14 @@ vm_pager_map_page(m)
        vm_offset_t kva;
 
 #ifdef DEBUG
        vm_offset_t kva;
 
 #ifdef DEBUG

-       if (!m->busy || m->active)
+       if (!(m->flags & PG_BUSY) || (m->flags & PG_ACTIVE))

                panic("vm_pager_map_page: page active or not busy");
                panic("vm_pager_map_page: page active or not busy");

-       if (m->pagerowned)
+       if (m->flags & PG_PAGEROWNED)

                printf("vm_pager_map_page: page %x already in pager\n", m);
 #endif
        kva = kmem_alloc_wait(pager_map, PAGE_SIZE);
 #ifdef DEBUG
                printf("vm_pager_map_page: page %x already in pager\n", m);
 #endif
        kva = kmem_alloc_wait(pager_map, PAGE_SIZE);
 #ifdef DEBUG

-       m->pagerowned = 1;
+       m->flags |= PG_PAGEROWNED;

 #endif
        pmap_enter(vm_map_pmap(pager_map), kva, VM_PAGE_TO_PHYS(m),
                   VM_PROT_DEFAULT, TRUE);
 #endif
        pmap_enter(vm_map_pmap(pager_map), kva, VM_PAGE_TO_PHYS(m),
                   VM_PROT_DEFAULT, TRUE);


@@ -225,8 +225,8 @@ vm_pager_unmap_page(kva)
 #endif
        kmem_free_wakeup(pager_map, kva, PAGE_SIZE);
 #ifdef DEBUG
 #endif
        kmem_free_wakeup(pager_map, kva, PAGE_SIZE);
 #ifdef DEBUG

-       if (m->pagerowned)
-               m->pagerowned = 0;
+       if (m->flags & PG_PAGEROWNED)
+               m->flags &= ~PG_PAGEROWNED;

        else
                printf("vm_pager_unmap_page: page %x(%x/%x) not owned\n",
                       m, kva, VM_PAGE_TO_PHYS(m));
        else
                printf("vm_pager_unmap_page: page %x(%x/%x) not owned\n",
                       m, kva, VM_PAGE_TO_PHYS(m));

diff --git a/sys/vm/vnode_pager.c b/sys/vm/vnode_pager.c
index 1280f80..744ef36 100644 (file)
--- a/sys/vm/vnode_pager.c
+++ b/sys/vm/vnode_pager.c
@@ -36,7 +36,7 @@
  * SUCH DAMAGE.
  *
  *     from: @(#)vnode_pager.c 7.5 (Berkeley) 4/20/91
  * SUCH DAMAGE.
  *
  *     from: @(#)vnode_pager.c 7.5 (Berkeley) 4/20/91

- *     $Id: vnode_pager.c,v 1.5 1993/12/19 00:56:17 wollman Exp $
+ *     $Id: vnode_pager.c,v 1.6 1993/12/19 23:24:18 wollman Exp $

  */
 
 /*
  */
 
 /*


@@ -240,7 +240,7 @@ vnode_pager_putpage(pager, m, sync)
                return 0;
        err = vnode_pager_io((vn_pager_t)pager->pg_data, m, UIO_WRITE);
        if (err == VM_PAGER_OK) {
                return 0;
        err = vnode_pager_io((vn_pager_t)pager->pg_data, m, UIO_WRITE);
        if (err == VM_PAGER_OK) {

-               m->clean = TRUE;                        /* XXX - wrong place */
+               m->flags |= PG_CLEAN;                   /* XXX - wrong place */

                pmap_clear_modify(VM_PAGE_TO_PHYS(m));  /* XXX - wrong place */
        }
        return(err);
                pmap_clear_modify(VM_PAGE_TO_PHYS(m));  /* XXX - wrong place */
        }
        return(err);