Converted vm_page bit fields to flags to allow for some optimizations

[unix-history] / sys / vm / vm_page.c

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++;
        }
 }