kernel - SWAP CACHE part 3/many - Rearrange VM pagerops
authorMatthew Dillon <dillon@apollo.backplane.com>
Wed, 3 Feb 2010 22:45:32 +0000 (14:45 -0800)
committerMatthew Dillon <dillon@apollo.backplane.com>
Wed, 3 Feb 2010 22:45:32 +0000 (14:45 -0800)
* Remove pgo_init, pgo_pageunswapped, and pgo_strategy

* The swap pager was the only consumer of pgo_pageunswapped and
  pgo_strategy.  Since these functions will soon operate on any
  VM object type and not just OBJT_SWAP there's no point putting
  them in pagerops.

* Make swap_pager_strategy() and swap_pager_unswapped() global
  functions and call them directly.

sys/dev/disk/vn/vn.c
sys/vm/default_pager.c
sys/vm/device_pager.c
sys/vm/phys_pager.c
sys/vm/swap_pager.c
sys/vm/vm_fault.c
sys/vm/vm_init.c
sys/vm/vm_pager.c
sys/vm/vm_pager.h
sys/vm/vnode_pager.c

index cc9a1df..10eb5b8 100644 (file)
@@ -275,7 +275,7 @@ vnopen(struct dev_open_args *ap)
  *     vnstrategy:
  *
  *     Run strategy routine for VN device.  We use VOP_READ/VOP_WRITE calls
- *     for vnode-backed vn's, and the new vm_pager_strategy() call for
+ *     for vnode-backed vn's, and the swap_pager_strategy() call for
  *     vm_object-backed vn's.
  */
 static int
@@ -376,7 +376,7 @@ vnstrategy(struct dev_strategy_args *ap)
                        bp->b_resid = 0;
                        /* operation complete */
                } else {
-                       vm_pager_strategy(vn->sc_object, nbio);
+                       swap_pager_strategy(vn->sc_object, nbio);
                        return(0);
                        /* NOT REACHED */
                }
index 94c79ff..e799a1a 100644 (file)
@@ -59,13 +59,11 @@ static boolean_t default_pager_haspage (vm_object_t, vm_pindex_t);
  * pagerops for OBJT_DEFAULT - "default pager".
  */
 struct pagerops defaultpagerops = {
-       NULL,
        default_pager_alloc,
        default_pager_dealloc,
        default_pager_getpage,
        default_pager_putpages,
-       default_pager_haspage,
-       NULL
+       default_pager_haspage
 };
 
 /*
index c4b606c..fe393cc 100644 (file)
@@ -56,7 +56,6 @@
 #include <vm/vm_pager.h>
 #include <vm/vm_zone.h>
 
-static void dev_pager_init (void);
 static vm_object_t dev_pager_alloc (void *, off_t, vm_prot_t, off_t);
 static void dev_pager_dealloc (vm_object_t);
 static int dev_pager_getpage (vm_object_t, vm_page_t *, int);
@@ -65,7 +64,8 @@ static void dev_pager_putpages (vm_object_t, vm_page_t *, int,
 static boolean_t dev_pager_haspage (vm_object_t, vm_pindex_t);
 
 /* list of device pager objects */
-static TAILQ_HEAD(, vm_page) dev_freepages_list;
+static TAILQ_HEAD(, vm_page) dev_freepages_list =
+               TAILQ_HEAD_INITIALIZER(dev_freepages_list);
 static MALLOC_DEFINE(M_FICTITIOUS_PAGES, "device-mapped pages", "Device mapped pages");
 
 static vm_page_t dev_pager_getfake (vm_paddr_t);
@@ -74,21 +74,13 @@ static void dev_pager_putfake (vm_page_t);
 static int dev_pager_alloc_lock, dev_pager_alloc_lock_want;
 
 struct pagerops devicepagerops = {
-       dev_pager_init,
        dev_pager_alloc,
        dev_pager_dealloc,
        dev_pager_getpage,
        dev_pager_putpages,
-       dev_pager_haspage,
-       NULL
+       dev_pager_haspage
 };
 
-static void
-dev_pager_init(void)
-{
-       TAILQ_INIT(&dev_freepages_list);
-}
-
 static vm_object_t
 dev_pager_alloc(void *handle, off_t size, vm_prot_t prot, off_t foff)
 {
index c1ff908..ca07c6c 100644 (file)
 
 #include <sys/thread2.h>
 
-static void
-phys_pager_init(void)
-{
-}
-
 static vm_object_t
 phys_pager_alloc(void *handle, off_t size, vm_prot_t prot, off_t foff)
 {
@@ -153,11 +148,9 @@ phys_pager_haspage(vm_object_t object, vm_pindex_t pindex)
 }
 
 struct pagerops physpagerops = {
-       phys_pager_init,
        phys_pager_alloc,
        phys_pager_dealloc,
        phys_pager_getpage,
        phys_pager_putpages,
-       phys_pager_haspage,
-       NULL
+       phys_pager_haspage
 };
index 4d4a8c6..584caaa 100644 (file)
@@ -195,20 +195,14 @@ static vm_object_t
                                  vm_prot_t prot, off_t offset);
 static void    swap_pager_dealloc (vm_object_t object);
 static int     swap_pager_getpage (vm_object_t, vm_page_t *, int);
-static void    swap_pager_init (void);
-static void    swap_pager_unswapped (vm_page_t);
-static void    swap_pager_strategy (vm_object_t, struct bio *);
 static void    swap_chain_iodone(struct bio *biox);
 
 struct pagerops swappagerops = {
-       swap_pager_init,        /* early system initialization of pager */
        swap_pager_alloc,       /* allocate an OBJT_SWAP object         */
        swap_pager_dealloc,     /* deallocate an OBJT_SWAP object       */
        swap_pager_getpage,     /* pagein                               */
        swap_pager_putpages,    /* pageout                              */
-       swap_pager_haspage,     /* get backing store status for page    */
-       swap_pager_unswapped,   /* remove swap related to page          */
-       swap_pager_strategy     /* pager strategy call                  */
+       swap_pager_haspage      /* get backing store status for page    */
 };
 
 /*
@@ -279,9 +273,8 @@ swp_sizecheck(void)
  *     before much else so be careful what you depend on.  Most of the VM
  *     system has yet to be initialized at this point.
  */
-
 static void
-swap_pager_init(void)
+swap_pager_init(void *arg __unused)
 {
        /*
         * Device Stripe, in PAGE_SIZE'd blocks
@@ -289,6 +282,7 @@ swap_pager_init(void)
        dmmax = SWB_NPAGES * 2;
        dmmax_mask = ~(dmmax - 1);
 }
+SYSINIT(vm_mem, SI_BOOT1_VM, SI_ORDER_THIRD, swap_pager_init, NULL)
 
 /*
  * SWAP_PAGER_SWAP_INIT() - swap pager initialization from pageout process
@@ -750,23 +744,23 @@ swap_pager_haspage(vm_object_t object, vm_pindex_t pindex)
 /*
  * SWAP_PAGER_PAGE_UNSWAPPED() - remove swap backing store related to page
  *
- *     This removes any associated swap backing store, whether valid or
- *     not, from the page.  
+ * This removes any associated swap backing store, whether valid or
+ * not, from the page.  This operates on any VM object, not just OBJT_SWAP
+ * objects.
  *
- *     This routine is typically called when a page is made dirty, at
- *     which point any associated swap can be freed.  MADV_FREE also
- *     calls us in a special-case situation
+ * This routine is typically called when a page is made dirty, at
+ * which point any associated swap can be freed.  MADV_FREE also
+ * calls us in a special-case situation
  *
- *     NOTE!!!  If the page is clean and the swap was valid, the caller
- *     should make the page dirty before calling this routine.  This routine
- *     does NOT change the m->dirty status of the page.  Also: MADV_FREE
- *     depends on it.
+ * NOTE!!!  If the page is clean and the swap was valid, the caller
+ * should make the page dirty before calling this routine.  This routine
+ * does NOT change the m->dirty status of the page.  Also: MADV_FREE
+ * depends on it.
  *
- *     This routine may not block
- *     This routine must be called at splvm()
+ * This routine may not block
+ * This routine must be called at splvm()
  */
-
-static void
+void
 swap_pager_unswapped(vm_page_t m)
 {
        swp_pager_meta_ctl(m->object, m->pindex, SWM_FREE);
@@ -775,20 +769,22 @@ swap_pager_unswapped(vm_page_t m)
 /*
  * SWAP_PAGER_STRATEGY() - read, write, free blocks
  *
- *     This implements the vm_pager_strategy() interface to swap and allows
- *     other parts of the system to directly access swap as backing store
- *     through vm_objects of type OBJT_SWAP.  This is intended to be a 
- *     cacheless interface ( i.e. caching occurs at higher levels ).
- *     Therefore we do not maintain any resident pages.  All I/O goes
- *     directly to and from the swap device.
+ * This implements a VM OBJECT strategy function using swap backing store.
+ * This can operate on any VM OBJECT type, not necessarily just OBJT_SWAP
+ * types.
+ *
+ * This is intended to be a cacheless interface (i.e. caching occurs at
+ * higher levels), and is also used as a swap-based SSD cache for vnode
+ * and device objects.
+ *
+ * All I/O goes directly to and from the swap device.
  *     
- *     We currently attempt to run I/O synchronously or asynchronously as
- *     the caller requests.  This isn't perfect because we loose error
- *     sequencing when we run multiple ops in parallel to satisfy a request.
- *     But this is swap, so we let it all hang out.
+ * We currently attempt to run I/O synchronously or asynchronously as
+ * the caller requests.  This isn't perfect because we loose error
+ * sequencing when we run multiple ops in parallel to satisfy a request.
+ * But this is swap, so we let it all hang out.
  */
-
-static void    
+void
 swap_pager_strategy(vm_object_t object, struct bio *bio)
 {
        struct buf *bp = bio->bio_buf;
index d00d2e8..02f3da0 100644 (file)
@@ -1450,7 +1450,7 @@ skip:
                if (fs->fault_flags & VM_FAULT_DIRTY) {
                        crit_enter();
                        vm_page_dirty(fs->m);
-                       vm_pager_page_unswapped(fs->m);
+                       swap_pager_unswapped(fs->m);
                        crit_exit();
                }
        }
index e37d0ee..1672791 100644 (file)
@@ -110,5 +110,4 @@ vm_mem_init(void *dummy)
        vm_map_startup();
        kmem_init(virtual_start, virtual_end);
        pmap_init();
-       vm_pager_init();
 }
index 0e5d305..ac25fdf 100644 (file)
@@ -141,13 +141,11 @@ dead_pager_dealloc(vm_object_t object)
 }
 
 static struct pagerops deadpagerops = {
-       NULL,
        dead_pager_alloc,
        dead_pager_dealloc,
        dead_pager_getpage,
        dead_pager_putpages,
-       dead_pager_haspage,
-       NULL
+       dead_pager_haspage
 };
 
 struct pagerops *pagertab[] = {
@@ -179,23 +177,15 @@ static vm_offset_t swapbkva;              /* swap buffers kva */
 static TAILQ_HEAD(swqueue, buf) bswlist;
 static struct spinlock bswspin = SPINLOCK_INITIALIZER(&bswspin);
 
-void
-vm_pager_init(void)
+static void
+vm_pager_init(void *arg __unused)
 {
-       struct pagerops **pgops;
-
        /*
         * Initialize the swap buffer list.
         */
        TAILQ_INIT(&bswlist);
-
-       /*
-        * Initialize known pagers
-        */
-       for (pgops = pagertab; pgops < &pagertab[npagers]; pgops++)
-               if (pgops && ((*pgops)->pgo_init != NULL))
-                       (*(*pgops)->pgo_init) ();
 }
+SYSINIT(vm_mem, SI_BOOT1_VM, SI_ORDER_SECOND, vm_pager_init, NULL)
 
 void
 vm_pager_bufferinit(void)
@@ -251,28 +241,6 @@ vm_pager_deallocate(vm_object_t object)
        (*pagertab[object->type]->pgo_dealloc) (object);
 }
 
-/*
- *      vm_pager_strategy:
- *
- *      called with no specific spl
- *      Execute strategy routine directly to pager.
- */
-
-void
-vm_pager_strategy(vm_object_t object, struct bio *bio)
-{
-       struct buf *bp;
-
-       if (pagertab[object->type]->pgo_strategy) {
-           (*pagertab[object->type]->pgo_strategy)(object, bio);
-       } else {
-               bp = bio->bio_buf;
-               bp->b_flags |= B_ERROR;
-               bp->b_error = ENXIO;
-               biodone(bio);
-       }
-}
-
 /*
  * vm_pager_get_pages() - inline, see vm/vm_pager.h
  * vm_pager_put_pages() - inline, see vm/vm_pager.h
index 425b886..e4f4cf3 100644 (file)
@@ -61,14 +61,11 @@ struct buf;
 struct bio;
 
 struct pagerops {
-       void (*pgo_init) (void);                /* Initialize pager. */
-       vm_object_t (*pgo_alloc) (void *, vm_ooffset_t, vm_prot_t, vm_ooffset_t);       /* Allocate pager. */
-       void (*pgo_dealloc) (vm_object_t);      /* Disassociate. */
+       vm_object_t (*pgo_alloc)(void *, vm_ooffset_t, vm_prot_t, vm_ooffset_t);
+       void (*pgo_dealloc) (vm_object_t);
        int (*pgo_getpage) (vm_object_t, vm_page_t *, int);
        void (*pgo_putpages) (vm_object_t, vm_page_t *, int, int, int *);
        boolean_t (*pgo_haspage) (vm_object_t, vm_pindex_t);
-       void (*pgo_pageunswapped) (vm_page_t);
-       void (*pgo_strategy) (vm_object_t, struct bio *);
 };
 
 /*
@@ -109,13 +106,13 @@ void vm_pager_bufferinit (void);
 void vm_pager_deallocate (vm_object_t);
 static __inline int vm_pager_get_page (vm_object_t, vm_page_t *, int);
 static __inline boolean_t vm_pager_has_page (vm_object_t, vm_pindex_t);
-void vm_pager_init (void);
 void vm_pager_sync (void);
-void vm_pager_strategy (vm_object_t object, struct bio *bio);
 struct buf *getchainbuf(struct buf *bp, struct vnode *vp, int flags);
 void flushchainbuf(struct buf *nbp);
 void waitchainbuf(struct buf *bp, int count, int done);
 void autochaindone(struct buf *bp);
+void swap_pager_strategy(vm_object_t object, struct bio *bio);
+void swap_pager_unswapped (vm_page_t m);
 
 /*
  * vm_page_get_pages:
@@ -168,21 +165,6 @@ vm_pager_has_page(vm_object_t object, vm_pindex_t offset)
         return ((*pagertab[object->type]->pgo_haspage)(object, offset));
 } 
 
-/* 
- *      vm_pager_page_unswapped
- * 
- *      called at splvm() to destroy swap associated with the page.
- * 
- *      This function may not block.
- */
-static __inline void
-vm_pager_page_unswapped(vm_page_t m)
-{
-       if (pagertab[m->object->type]->pgo_pageunswapped)
-               (*pagertab[m->object->type]->pgo_pageunswapped)(m);
-}
-
 #endif
 
 #endif                         /* _VM_VM_PAGER_H_ */
index 6ed430a..47d143a 100644 (file)
@@ -80,13 +80,11 @@ static void vnode_pager_putpages (vm_object_t, vm_page_t *, int, boolean_t, int
 static boolean_t vnode_pager_haspage (vm_object_t, vm_pindex_t);
 
 struct pagerops vnodepagerops = {
-       NULL,
        vnode_pager_alloc,
        vnode_pager_dealloc,
        vnode_pager_getpage,
        vnode_pager_putpages,
-       vnode_pager_haspage,
-       NULL
+       vnode_pager_haspage
 };
 
 static struct krate vbadrate = { 1 };