__P()!=wanted, clean up the vm subsystem
authorRobert Garrett <rob@dragonflybsd.org>
Wed, 20 Aug 2003 08:03:01 +0000 (08:03 +0000)
committerRobert Garrett <rob@dragonflybsd.org>
Wed, 20 Aug 2003 08:03:01 +0000 (08:03 +0000)
22 files changed:
sys/vm/default_pager.c
sys/vm/device_pager.c
sys/vm/pmap.h
sys/vm/swap_pager.c
sys/vm/swap_pager.h
sys/vm/vm_extern.h
sys/vm/vm_fault.c
sys/vm/vm_glue.c
sys/vm/vm_init.c
sys/vm/vm_map.c
sys/vm/vm_map.h
sys/vm/vm_mmap.c
sys/vm/vm_object.c
sys/vm/vm_object.h
sys/vm/vm_pageout.c
sys/vm/vm_pageout.h
sys/vm/vm_pager.c
sys/vm/vm_pager.h
sys/vm/vm_swap.c
sys/vm/vm_zone.h
sys/vm/vnode_pager.c
sys/vm/vnode_pager.h

index 0cc0712..0a8c675 100644 (file)
@@ -37,7 +37,7 @@
  * is maintained whenever a resident page also has swap backing store.
  *
  * $FreeBSD: src/sys/vm/default_pager.c,v 1.23 1999/11/07 20:03:53 alc Exp $
- * $DragonFly: src/sys/vm/default_pager.c,v 1.2 2003/06/17 04:29:00 dillon Exp $
+ * $DragonFly: src/sys/vm/default_pager.c,v 1.3 2003/08/20 08:03:01 rob Exp $
  */
 
 #include <sys/param.h>
 #include <vm/vm_pager.h>
 #include <vm/swap_pager.h>
 
-static vm_object_t default_pager_alloc __P((void *, vm_ooffset_t, vm_prot_t,
-               vm_ooffset_t));
-static void default_pager_dealloc __P((vm_object_t));
-static int default_pager_getpages __P((vm_object_t, vm_page_t *, int, int));
-static void default_pager_putpages __P((vm_object_t, vm_page_t *, int, 
-               boolean_t, int *));
-static boolean_t default_pager_haspage __P((vm_object_t, vm_pindex_t, int *, 
-               int *));
+static vm_object_t default_pager_alloc (void *, vm_ooffset_t, vm_prot_t,
+               vm_ooffset_t);
+static void default_pager_dealloc (vm_object_t);
+static int default_pager_getpages (vm_object_t, vm_page_t *, int, int);
+static void default_pager_putpages (vm_object_t, vm_page_t *, int, 
+               boolean_t, int *);
+static boolean_t default_pager_haspage (vm_object_t, vm_pindex_t, int *, 
+               int *);
 /*
  * pagerops for OBJT_DEFAULT - "default pager".
  */
index 9be654c..83938ad 100644 (file)
@@ -37,7 +37,7 @@
  *
  *     @(#)device_pager.c      8.1 (Berkeley) 6/11/93
  * $FreeBSD: src/sys/vm/device_pager.c,v 1.46.2.1 2000/08/02 21:54:37 peter Exp $
- * $DragonFly: src/sys/vm/device_pager.c,v 1.4 2003/07/22 17:03:35 dillon Exp $
+ * $DragonFly: src/sys/vm/device_pager.c,v 1.5 2003/08/20 08:03:01 rob Exp $
  */
 
 #include <sys/param.h>
 #include <vm/vm_pager.h>
 #include <vm/vm_zone.h>
 
-static void dev_pager_init __P((void));
-static vm_object_t dev_pager_alloc __P((void *, vm_ooffset_t, vm_prot_t,
-               vm_ooffset_t));
-static void dev_pager_dealloc __P((vm_object_t));
-static int dev_pager_getpages __P((vm_object_t, vm_page_t *, int, int));
-static void dev_pager_putpages __P((vm_object_t, vm_page_t *, int, 
-               boolean_t, int *));
-static boolean_t dev_pager_haspage __P((vm_object_t, vm_pindex_t, int *,
-               int *));
+static void dev_pager_init (void);
+static vm_object_t dev_pager_alloc (void *, vm_ooffset_t, vm_prot_t,
+               vm_ooffset_t);
+static void dev_pager_dealloc (vm_object_t);
+static int dev_pager_getpages (vm_object_t, vm_page_t *, int, int);
+static void dev_pager_putpages (vm_object_t, vm_page_t *, int, 
+               boolean_t, int *);
+static boolean_t dev_pager_haspage (vm_object_t, vm_pindex_t, int *,
+               int *);
 
 /* list of device pager objects */
 static struct pagerlst dev_pager_object_list;
@@ -68,8 +68,8 @@ static struct pagerlst dev_pager_object_list;
 static vm_zone_t fakepg_zone;
 static struct vm_zone fakepg_zone_store;
 
-static vm_page_t dev_pager_getfake __P((vm_offset_t));
-static void dev_pager_putfake __P((vm_page_t));
+static vm_page_t dev_pager_getfake (vm_offset_t);
+static void dev_pager_putfake (vm_page_t);
 
 static int dev_pager_alloc_lock, dev_pager_alloc_lock_want;
 
index fab9153..b751dbf 100644 (file)
@@ -62,7 +62,7 @@
  * rights to redistribute these changes.
  *
  * $FreeBSD: src/sys/vm/pmap.h,v 1.33.2.4 2002/03/06 22:44:24 silby Exp $
- * $DragonFly: src/sys/vm/pmap.h,v 1.6 2003/06/27 03:30:43 dillon Exp $
+ * $DragonFly: src/sys/vm/pmap.h,v 1.7 2003/08/20 08:03:01 rob Exp $
  */
 
 /*
@@ -93,58 +93,58 @@ struct proc;
 struct thread;
 
 #ifdef __alpha__
-void            pmap_page_is_free __P((vm_page_t m));
+void            pmap_page_is_free (vm_page_t m);
 #endif
-void            pmap_change_wiring __P((pmap_t, vm_offset_t, boolean_t));
-void            pmap_clear_modify __P((vm_page_t m));
-void            pmap_clear_reference __P((vm_page_t m));
-void            pmap_collect __P((void));
-void            pmap_copy __P((pmap_t, pmap_t, vm_offset_t, vm_size_t,
-                   vm_offset_t));
-void            pmap_copy_page __P((vm_offset_t, vm_offset_t));
-void            pmap_destroy __P((pmap_t));
-void            pmap_enter __P((pmap_t, vm_offset_t, vm_page_t, vm_prot_t,
-                   boolean_t));
-vm_offset_t     pmap_extract __P((pmap_t pmap, vm_offset_t va));
-void            pmap_growkernel __P((vm_offset_t));
-void            pmap_init __P((vm_offset_t, vm_offset_t));
-boolean_t       pmap_is_modified __P((vm_page_t m));
-boolean_t       pmap_ts_referenced __P((vm_page_t m));
-void            pmap_kenter __P((vm_offset_t va, vm_offset_t pa));
-void            pmap_kremove __P((vm_offset_t));
-vm_offset_t     pmap_map __P((vm_offset_t, vm_offset_t, vm_offset_t, int));
-void            pmap_object_init_pt __P((pmap_t pmap, vm_offset_t addr,
+void            pmap_change_wiring (pmap_t, vm_offset_t, boolean_t);
+void            pmap_clear_modify (vm_page_t m);
+void            pmap_clear_reference (vm_page_t m);
+void            pmap_collect (void);
+void            pmap_copy (pmap_t, pmap_t, vm_offset_t, vm_size_t,
+                   vm_offset_t);
+void            pmap_copy_page (vm_offset_t, vm_offset_t);
+void            pmap_destroy (pmap_t);
+void            pmap_enter (pmap_t, vm_offset_t, vm_page_t, vm_prot_t,
+                   boolean_t);
+vm_offset_t     pmap_extract (pmap_t pmap, vm_offset_t va);
+void            pmap_growkernel (vm_offset_t);
+void            pmap_init (vm_offset_t, vm_offset_t);
+boolean_t       pmap_is_modified (vm_page_t m);
+boolean_t       pmap_ts_referenced (vm_page_t m);
+void            pmap_kenter (vm_offset_t va, vm_offset_t pa);
+void            pmap_kremove (vm_offset_t);
+vm_offset_t     pmap_map (vm_offset_t, vm_offset_t, vm_offset_t, int);
+void            pmap_object_init_pt (pmap_t pmap, vm_offset_t addr,
                    vm_object_t object, vm_pindex_t pindex, vm_offset_t size,
-                   int pagelimit));
-boolean_t       pmap_page_exists_quick __P((pmap_t pmap, vm_page_t m));
-void            pmap_page_protect __P((vm_page_t m, vm_prot_t prot));
-void            pmap_pageable __P((pmap_t, vm_offset_t, vm_offset_t,
-                   boolean_t));
-vm_offset_t     pmap_phys_address __P((int));
-void            pmap_pinit __P((pmap_t));
-void            pmap_pinit0 __P((pmap_t));
-void            pmap_pinit2 __P((pmap_t));
-void            pmap_protect __P((pmap_t, vm_offset_t, vm_offset_t,
-                   vm_prot_t));
-void            pmap_qenter __P((vm_offset_t, vm_page_t *, int));
-void            pmap_qremove __P((vm_offset_t, int));
-void            pmap_reference __P((pmap_t));
-void            pmap_release __P((pmap_t));
-void            pmap_remove __P((pmap_t, vm_offset_t, vm_offset_t));
-void            pmap_remove_pages __P((pmap_t, vm_offset_t, vm_offset_t));
-void            pmap_zero_page __P((vm_offset_t));
-void            pmap_zero_page_area __P((vm_offset_t, int off, int size));
-void            pmap_prefault __P((pmap_t, vm_offset_t, vm_map_entry_t));
-int             pmap_mincore __P((pmap_t pmap, vm_offset_t addr));
-void            pmap_init_proc __P((struct proc *p, struct thread *td));
-void            pmap_init_thread __P((struct thread *td));
-struct thread  *pmap_dispose_proc __P((struct proc *p));
-void            pmap_swapout_proc __P((struct proc *p));
-void            pmap_swapin_proc __P((struct proc *p));
-void            pmap_activate __P((struct proc *p));
-vm_offset_t     pmap_addr_hint __P((vm_object_t obj, vm_offset_t addr, vm_size_t size));
-void           *pmap_kenter_temporary __P((vm_offset_t pa, int i));
-void            pmap_init2 __P((void));
+                   int pagelimit);
+boolean_t       pmap_page_exists_quick (pmap_t pmap, vm_page_t m);
+void            pmap_page_protect (vm_page_t m, vm_prot_t prot);
+void            pmap_pageable (pmap_t, vm_offset_t, vm_offset_t,
+                   boolean_t);
+vm_offset_t     pmap_phys_address (int);
+void            pmap_pinit (pmap_t);
+void            pmap_pinit0 (pmap_t);
+void            pmap_pinit2 (pmap_t);
+void            pmap_protect (pmap_t, vm_offset_t, vm_offset_t,
+                   vm_prot_t);
+void            pmap_qenter (vm_offset_t, vm_page_t *, int);
+void            pmap_qremove (vm_offset_t, int);
+void            pmap_reference (pmap_t);
+void            pmap_release (pmap_t);
+void            pmap_remove (pmap_t, vm_offset_t, vm_offset_t);
+void            pmap_remove_pages (pmap_t, vm_offset_t, vm_offset_t);
+void            pmap_zero_page (vm_offset_t);
+void            pmap_zero_page_area (vm_offset_t, int off, int size);
+void            pmap_prefault (pmap_t, vm_offset_t, vm_map_entry_t);
+int             pmap_mincore (pmap_t pmap, vm_offset_t addr);
+void            pmap_init_proc (struct proc *p, struct thread *td);
+void            pmap_init_thread (struct thread *td);
+struct thread  *pmap_dispose_proc (struct proc *p);
+void            pmap_swapout_proc (struct proc *p);
+void            pmap_swapin_proc (struct proc *p);
+void            pmap_activate (struct proc *p);
+vm_offset_t     pmap_addr_hint (vm_object_t obj, vm_offset_t addr, vm_size_t size);
+void           *pmap_kenter_temporary (vm_offset_t pa, int i);
+void            pmap_init2 (void);
 
 #endif /* _KERNEL */
 
index 55c945f..e3a419e 100644 (file)
@@ -65,7 +65,7 @@
  *     @(#)swap_pager.c        8.9 (Berkeley) 3/21/94
  *
  * $FreeBSD: src/sys/vm/swap_pager.c,v 1.130.2.12 2002/08/31 21:15:55 dillon Exp $
- * $DragonFly: src/sys/vm/swap_pager.c,v 1.9 2003/07/26 22:10:02 rob Exp $
+ * $DragonFly: src/sys/vm/swap_pager.c,v 1.10 2003/08/20 08:03:01 rob Exp $
  */
 
 #include <sys/param.h>
@@ -151,13 +151,13 @@ vm_zone_t         swap_zone;
  */
 
 static vm_object_t
-               swap_pager_alloc __P((void *handle, vm_ooffset_t size,
-                                     vm_prot_t prot, vm_ooffset_t offset));
-static void    swap_pager_dealloc __P((vm_object_t object));
-static int     swap_pager_getpages __P((vm_object_t, vm_page_t *, int, int));
-static void    swap_pager_init __P((void));
-static void    swap_pager_unswapped __P((vm_page_t));
-static void    swap_pager_strategy __P((vm_object_t, struct buf *));
+               swap_pager_alloc (void *handle, vm_ooffset_t size,
+                                     vm_prot_t prot, vm_ooffset_t offset);
+static void    swap_pager_dealloc (vm_object_t object);
+static int     swap_pager_getpages (vm_object_t, vm_page_t *, int, int);
+static void    swap_pager_init (void);
+static void    swap_pager_unswapped (vm_page_t);
+static void    swap_pager_strategy (vm_object_t, struct buf *);
 
 struct pagerops swappagerops = {
        swap_pager_init,        /* early system initialization of pager */
@@ -183,25 +183,25 @@ static int dmmax_mask;
 int nswap_lowat = 128;         /* in pages, swap_pager_almost_full warn */
 int nswap_hiwat = 512;         /* in pages, swap_pager_almost_full warn */
 
-static __inline void   swp_sizecheck __P((void));
-static void    swp_pager_sync_iodone __P((struct buf *bp));
-static void    swp_pager_async_iodone __P((struct buf *bp));
+static __inline void   swp_sizecheck (void);
+static void    swp_pager_sync_iodone (struct buf *bp);
+static void    swp_pager_async_iodone (struct buf *bp);
 
 /*
  * Swap bitmap functions
  */
 
-static __inline void   swp_pager_freeswapspace __P((daddr_t blk, int npages));
-static __inline daddr_t        swp_pager_getswapspace __P((int npages));
+static __inline void   swp_pager_freeswapspace (daddr_t blk, int npages);
+static __inline daddr_t        swp_pager_getswapspace (int npages);
 
 /*
  * Metadata functions
  */
 
-static void swp_pager_meta_build __P((vm_object_t, vm_pindex_t, daddr_t));
-static void swp_pager_meta_free __P((vm_object_t, vm_pindex_t, daddr_t));
-static void swp_pager_meta_free_all __P((vm_object_t));
-static daddr_t swp_pager_meta_ctl __P((vm_object_t, vm_pindex_t, int));
+static void swp_pager_meta_build (vm_object_t, vm_pindex_t, daddr_t);
+static void swp_pager_meta_free (vm_object_t, vm_pindex_t, daddr_t);
+static void swp_pager_meta_free_all (vm_object_t);
+static daddr_t swp_pager_meta_ctl (vm_object_t, vm_pindex_t, int);
 
 /*
  * SWP_SIZECHECK() -   update swap_pager_full indication
index 5a59811..19a9c8c 100644 (file)
@@ -37,7 +37,7 @@
  *
  *     from: @(#)swap_pager.h  7.1 (Berkeley) 12/5/90
  * $FreeBSD: src/sys/vm/swap_pager.h,v 1.28.2.1 2000/10/13 07:13:23 dillon Exp $
- * $DragonFly: src/sys/vm/swap_pager.h,v 1.2 2003/06/17 04:29:00 dillon Exp $
+ * $DragonFly: src/sys/vm/swap_pager.h,v 1.3 2003/08/20 08:03:01 rob Exp $
  */
 
 /*
@@ -86,25 +86,25 @@ extern struct pagerlst swap_pager_un_object_list;
 extern int swap_pager_full;
 extern struct blist *swapblist;
 
-void swap_pager_putpages __P((vm_object_t, vm_page_t *, int, boolean_t, int *));
-boolean_t swap_pager_haspage __P((vm_object_t object, vm_pindex_t pindex, int *before, int *after));
+void swap_pager_putpages (vm_object_t, vm_page_t *, int, boolean_t, int *);
+boolean_t swap_pager_haspage (vm_object_t object, vm_pindex_t pindex, int *before, int *after);
 
-int swap_pager_swp_alloc __P((vm_object_t, int));
-void swap_pager_copy __P((vm_object_t, vm_object_t, vm_pindex_t, int));
-void swap_pager_freespace __P((vm_object_t, vm_pindex_t, vm_size_t));
-void swap_pager_dmzspace __P((vm_object_t, vm_pindex_t, vm_size_t));
-void swap_pager_swap_init __P((void));
-int swap_pager_reserve __P((vm_object_t, vm_pindex_t, vm_size_t));
+int swap_pager_swp_alloc (vm_object_t, int);
+void swap_pager_copy (vm_object_t, vm_object_t, vm_pindex_t, int);
+void swap_pager_freespace (vm_object_t, vm_pindex_t, vm_size_t);
+void swap_pager_dmzspace (vm_object_t, vm_pindex_t, vm_size_t);
+void swap_pager_swap_init (void);
+int swap_pager_reserve (vm_object_t, vm_pindex_t, vm_size_t);
 
 /*
  * newswap functions
  */
 
-void swap_pager_page_removed __P((vm_page_t, vm_object_t));
+void swap_pager_page_removed (vm_page_t, vm_object_t);
 
 /* choose underlying swap device and queue up I/O */
 struct buf;
-void swstrategy __P((struct buf *bp)); /* probably needs to move elsewhere */
+void swstrategy (struct buf *bp);      /* probably needs to move elsewhere */
 
 #endif
 
index 44b1174..3d9d19a 100644 (file)
@@ -32,7 +32,7 @@
  *
  *     @(#)vm_extern.h 8.2 (Berkeley) 1/12/94
  * $FreeBSD: src/sys/vm/vm_extern.h,v 1.46.2.3 2003/01/13 22:51:17 dillon Exp $
- * $DragonFly: src/sys/vm/vm_extern.h,v 1.3 2003/06/25 03:56:12 dillon Exp $
+ * $DragonFly: src/sys/vm/vm_extern.h,v 1.4 2003/08/20 08:03:01 rob Exp $
  */
 
 #ifndef _VM_EXTERN_H_
@@ -48,56 +48,56 @@ struct vnode;
 #ifdef _KERNEL
 
 #ifdef TYPEDEF_FOR_UAP
-int getpagesize __P((struct proc * p, void *, int *));
-int madvise __P((struct proc *, void *, int *));
-int mincore __P((struct proc *, void *, int *));
-int mprotect __P((struct proc *, void *, int *));
-int msync __P((struct proc *, void *, int *));
-int munmap __P((struct proc *, void *, int *));
-int obreak __P((struct proc *, void *, int *));
-int sbrk __P((struct proc *, void *, int *));
-int sstk __P((struct proc *, void *, int *));
-int swapon __P((struct proc *, void *, int *));
+int getpagesize (struct proc * p, void *, int *);
+int madvise (struct proc *, void *, int *);
+int mincore (struct proc *, void *, int *);
+int mprotect (struct proc *, void *, int *);
+int msync (struct proc *, void *, int *);
+int munmap (struct proc *, void *, int *);
+int obreak (struct proc *, void *, int *);
+int sbrk (struct proc *, void *, int *);
+int sstk (struct proc *, void *, int *);
+int swapon (struct proc *, void *, int *);
 #endif
 
-int grow __P((struct proc *, size_t));
-int grow_stack __P((struct proc *, size_t));
-int kernacc __P((caddr_t, int, int));
-vm_offset_t kmem_alloc __P((vm_map_t, vm_size_t));
-vm_offset_t kmem_alloc_nofault __P((vm_map_t, vm_size_t));
-vm_offset_t kmem_alloc_pageable __P((vm_map_t, vm_size_t));
-vm_offset_t kmem_alloc_wait __P((vm_map_t, vm_size_t));
-void kmem_free __P((vm_map_t, vm_offset_t, vm_size_t));
-void kmem_free_wakeup __P((vm_map_t, vm_offset_t, vm_size_t));
-void kmem_init __P((vm_offset_t, vm_offset_t));
-vm_offset_t kmem_malloc __P((vm_map_t, vm_size_t, boolean_t));
-vm_map_t kmem_suballoc __P((vm_map_t, vm_offset_t *, vm_offset_t *, vm_size_t));
-void munmapfd __P((struct proc *, int));
-int swaponvp __P((struct thread *, struct vnode *, dev_t , u_long));
-void swapout_procs __P((int));
-int useracc __P((caddr_t, int, int));
-int vm_fault __P((vm_map_t, vm_offset_t, vm_prot_t, int));
-void vm_fault_copy_entry __P((vm_map_t, vm_map_t, vm_map_entry_t, vm_map_entry_t));
-void vm_fault_unwire __P((vm_map_t, vm_offset_t, vm_offset_t));
-int vm_fault_wire __P((vm_map_t, vm_offset_t, vm_offset_t));
-int vm_fault_user_wire __P((vm_map_t, vm_offset_t, vm_offset_t));
-void vm_fork __P((struct proc *, struct proc *, int));
-void vm_waitproc __P((struct proc *));
-int vm_mmap __P((vm_map_t, vm_offset_t *, vm_size_t, vm_prot_t, vm_prot_t, int, void *, vm_ooffset_t));
-vm_offset_t vm_page_alloc_contig __P((vm_offset_t, vm_offset_t, vm_offset_t, vm_offset_t));
-void vm_set_page_size __P((void));
-struct vmspace *vmspace_alloc __P((vm_offset_t, vm_offset_t));
-struct vmspace *vmspace_fork __P((struct vmspace *));
-void vmspace_exec __P((struct proc *));
-void vmspace_unshare __P((struct proc *));
-void vmspace_free __P((struct vmspace *));
-void vmspace_exitfree __P((struct proc *));
-void vnode_pager_setsize __P((struct vnode *, vm_ooffset_t));
-void vslock __P((caddr_t, u_int));
-void vsunlock __P((caddr_t, u_int));
-void vm_object_print __P((/* db_expr_t */ long, boolean_t, /* db_expr_t */ long,
-                         char *));
-int vm_fault_quick __P((caddr_t v, int prot));
+int grow (struct proc *, size_t);
+int grow_stack (struct proc *, size_t);
+int kernacc (caddr_t, int, int);
+vm_offset_t kmem_alloc (vm_map_t, vm_size_t);
+vm_offset_t kmem_alloc_nofault (vm_map_t, vm_size_t);
+vm_offset_t kmem_alloc_pageable (vm_map_t, vm_size_t);
+vm_offset_t kmem_alloc_wait (vm_map_t, vm_size_t);
+void kmem_free (vm_map_t, vm_offset_t, vm_size_t);
+void kmem_free_wakeup (vm_map_t, vm_offset_t, vm_size_t);
+void kmem_init (vm_offset_t, vm_offset_t);
+vm_offset_t kmem_malloc (vm_map_t, vm_size_t, boolean_t);
+vm_map_t kmem_suballoc (vm_map_t, vm_offset_t *, vm_offset_t *, vm_size_t);
+void munmapfd (struct proc *, int);
+int swaponvp (struct thread *, struct vnode *, dev_t , u_long);
+void swapout_procs (int);
+int useracc (caddr_t, int, int);
+int vm_fault (vm_map_t, vm_offset_t, vm_prot_t, int);
+void vm_fault_copy_entry (vm_map_t, vm_map_t, vm_map_entry_t, vm_map_entry_t);
+void vm_fault_unwire (vm_map_t, vm_offset_t, vm_offset_t);
+int vm_fault_wire (vm_map_t, vm_offset_t, vm_offset_t);
+int vm_fault_user_wire (vm_map_t, vm_offset_t, vm_offset_t);
+void vm_fork (struct proc *, struct proc *, int);
+void vm_waitproc (struct proc *);
+int vm_mmap (vm_map_t, vm_offset_t *, vm_size_t, vm_prot_t, vm_prot_t, int, void *, vm_ooffset_t);
+vm_offset_t vm_page_alloc_contig (vm_offset_t, vm_offset_t, vm_offset_t, vm_offset_t);
+void vm_set_page_size (void);
+struct vmspace *vmspace_alloc (vm_offset_t, vm_offset_t);
+struct vmspace *vmspace_fork (struct vmspace *);
+void vmspace_exec (struct proc *);
+void vmspace_unshare (struct proc *);
+void vmspace_free (struct vmspace *);
+void vmspace_exitfree (struct proc *);
+void vnode_pager_setsize (struct vnode *, vm_ooffset_t);
+void vslock (caddr_t, u_int);
+void vsunlock (caddr_t, u_int);
+void vm_object_print (/* db_expr_t */ long, boolean_t, /* db_expr_t */ long,
+                         char *);
+int vm_fault_quick (caddr_t v, int prot);
 
 #endif                         /* _KERNEL */
 
index 8d04fdd..9ae4c3a 100644 (file)
@@ -67,7 +67,7 @@
  * rights to redistribute these changes.
  *
  * $FreeBSD: src/sys/vm/vm_fault.c,v 1.108.2.8 2002/02/26 05:49:27 silby Exp $
- * $DragonFly: src/sys/vm/vm_fault.c,v 1.5 2003/07/26 22:10:02 rob Exp $
+ * $DragonFly: src/sys/vm/vm_fault.c,v 1.6 2003/08/20 08:03:01 rob Exp $
  */
 
 /*
@@ -95,8 +95,8 @@
 #include <vm/vm_extern.h>
 #include <vm/vm_page2.h>
 
-static int vm_fault_additional_pages __P((vm_page_t, int,
-                                         int, vm_page_t *, int *));
+static int vm_fault_additional_pages (vm_page_t, int,
+                                         int, vm_page_t *, int *);
 
 #define VM_FAULT_READ_AHEAD 8
 #define VM_FAULT_READ_BEHIND 7
index 68daff9..7512e75 100644 (file)
@@ -60,7 +60,7 @@
  * rights to redistribute these changes.
  *
  * $FreeBSD: src/sys/vm/vm_glue.c,v 1.94.2.4 2003/01/13 22:51:17 dillon Exp $
- * $DragonFly: src/sys/vm/vm_glue.c,v 1.14 2003/07/26 22:10:02 rob Exp $
+ * $DragonFly: src/sys/vm/vm_glue.c,v 1.15 2003/08/20 08:03:01 rob Exp $
  */
 
 #include "opt_vm.h"
@@ -98,7 +98,7 @@
  * Note: proc0 from proc.h
  */
 
-static void vm_init_limits __P((void *));
+static void vm_init_limits (void *);
 SYSINIT(vm_limits, SI_SUB_VM_CONF, SI_ORDER_FIRST, vm_init_limits, &proc0)
 
 /*
@@ -106,11 +106,11 @@ SYSINIT(vm_limits, SI_SUB_VM_CONF, SI_ORDER_FIRST, vm_init_limits, &proc0)
  *
  * Note: run scheduling should be divorced from the vm system.
  */
-static void scheduler __P((void *));
+static void scheduler (void *);
 SYSINIT(scheduler, SI_SUB_RUN_SCHEDULER, SI_ORDER_FIRST, scheduler, NULL)
 
 
-static void swapout __P((struct proc *));
+static void swapout (struct proc *);
 
 int
 kernacc(addr, len, rw)
index ea45df3..2187786 100644 (file)
@@ -62,7 +62,7 @@
  * rights to redistribute these changes.
  *
  * $FreeBSD: src/sys/vm/vm_init.c,v 1.20 1999/10/29 18:09:29 phk Exp $
- * $DragonFly: src/sys/vm/vm_init.c,v 1.2 2003/06/17 04:29:00 dillon Exp $
+ * $DragonFly: src/sys/vm/vm_init.c,v 1.3 2003/08/20 08:03:01 rob Exp $
  */
 
 /*
@@ -85,7 +85,7 @@
  * System initialization
  */
 
-static void vm_mem_init __P((void *));
+static void vm_mem_init (void *);
 SYSINIT(vm_mem, SI_SUB_VM, SI_ORDER_FIRST, vm_mem_init, NULL)
 
 /*
index 92479d1..c70028c 100644 (file)
@@ -62,7 +62,7 @@
  * rights to redistribute these changes.
  *
  * $FreeBSD: src/sys/vm/vm_map.c,v 1.187.2.19 2003/05/27 00:47:02 alc Exp $
- * $DragonFly: src/sys/vm/vm_map.c,v 1.7 2003/07/23 07:14:19 dillon Exp $
+ * $DragonFly: src/sys/vm/vm_map.c,v 1.8 2003/08/20 08:03:01 rob Exp $
  */
 
 /*
@@ -139,16 +139,16 @@ static struct vm_map_entry map_entry_init[MAX_MAPENT];
 static struct vm_map_entry kmap_entry_init[MAX_KMAPENT];
 static struct vm_map map_init[MAX_KMAP];
 
-static void _vm_map_clip_end __P((vm_map_t, vm_map_entry_t, vm_offset_t));
-static void _vm_map_clip_start __P((vm_map_t, vm_map_entry_t, vm_offset_t));
-static vm_map_entry_t vm_map_entry_create __P((vm_map_t));
-static void vm_map_entry_delete __P((vm_map_t, vm_map_entry_t));
-static void vm_map_entry_dispose __P((vm_map_t, vm_map_entry_t));
-static void vm_map_entry_unwire __P((vm_map_t, vm_map_entry_t));
-static void vm_map_copy_entry __P((vm_map_t, vm_map_t, vm_map_entry_t,
-               vm_map_entry_t));
-static void vm_map_split __P((vm_map_entry_t));
-static void vm_map_unclip_range __P((vm_map_t map, vm_map_entry_t start_entry, vm_offset_t start, vm_offset_t end, int flags));
+static void _vm_map_clip_end (vm_map_t, vm_map_entry_t, vm_offset_t);
+static void _vm_map_clip_start (vm_map_t, vm_map_entry_t, vm_offset_t);
+static vm_map_entry_t vm_map_entry_create (vm_map_t);
+static void vm_map_entry_delete (vm_map_t, vm_map_entry_t);
+static void vm_map_entry_dispose (vm_map_t, vm_map_entry_t);
+static void vm_map_entry_unwire (vm_map_t, vm_map_entry_t);
+static void vm_map_copy_entry (vm_map_t, vm_map_t, vm_map_entry_t,
+               vm_map_entry_t);
+static void vm_map_split (vm_map_entry_t);
+static void vm_map_unclip_range (vm_map_t map, vm_map_entry_t start_entry, vm_offset_t start, vm_offset_t end, int flags);
 
 void
 vm_map_startup()
index e7cc6f0..4ae2425 100644 (file)
@@ -62,7 +62,7 @@
  * rights to redistribute these changes.
  *
  * $FreeBSD: src/sys/vm/vm_map.h,v 1.54.2.5 2003/01/13 22:51:17 dillon Exp $
- * $DragonFly: src/sys/vm/vm_map.h,v 1.4 2003/07/06 21:23:56 dillon Exp $
+ * $DragonFly: src/sys/vm/vm_map.h,v 1.5 2003/08/20 08:03:01 rob Exp $
  */
 
 /*
@@ -358,34 +358,34 @@ vmspace_resident_count(struct vmspace *vmspace)
 #define VM_FAULT_DIRTY 8               /* Dirty the page */
 
 #ifdef _KERNEL
-boolean_t vm_map_check_protection __P((vm_map_t, vm_offset_t, vm_offset_t, vm_prot_t));
+boolean_t vm_map_check_protection (vm_map_t, vm_offset_t, vm_offset_t, vm_prot_t);
 struct pmap;
-vm_map_t vm_map_create __P((struct pmap *, vm_offset_t, vm_offset_t));
-int vm_map_delete __P((vm_map_t, vm_offset_t, vm_offset_t));
-int vm_map_find __P((vm_map_t, vm_object_t, vm_ooffset_t, vm_offset_t *, vm_size_t, boolean_t, vm_prot_t, vm_prot_t, int));
-int vm_map_findspace __P((vm_map_t, vm_offset_t, vm_size_t, vm_offset_t *));
-int vm_map_inherit __P((vm_map_t, vm_offset_t, vm_offset_t, vm_inherit_t));
-void vm_map_init __P((struct vm_map *, vm_offset_t, vm_offset_t));
-int vm_map_insert __P((vm_map_t, vm_object_t, vm_ooffset_t, vm_offset_t, vm_offset_t, vm_prot_t, vm_prot_t, int));
-int vm_map_lookup __P((vm_map_t *, vm_offset_t, vm_prot_t, vm_map_entry_t *, vm_object_t *,
-    vm_pindex_t *, vm_prot_t *, boolean_t *));
-void vm_map_lookup_done __P((vm_map_t, vm_map_entry_t));
-boolean_t vm_map_lookup_entry __P((vm_map_t, vm_offset_t, vm_map_entry_t *));
-int vm_map_pageable __P((vm_map_t, vm_offset_t, vm_offset_t, boolean_t));
-int vm_map_user_pageable __P((vm_map_t, vm_offset_t, vm_offset_t, boolean_t));
-int vm_map_clean __P((vm_map_t, vm_offset_t, vm_offset_t, boolean_t, boolean_t));
-int vm_map_protect __P((vm_map_t, vm_offset_t, vm_offset_t, vm_prot_t, boolean_t));
-int vm_map_remove __P((vm_map_t, vm_offset_t, vm_offset_t));
-void vm_map_startup __P((void));
-int vm_map_submap __P((vm_map_t, vm_offset_t, vm_offset_t, vm_map_t));
-int vm_map_madvise __P((vm_map_t, vm_offset_t, vm_offset_t, int));
-void vm_map_simplify_entry __P((vm_map_t, vm_map_entry_t));
-void vm_init2 __P((void));
-int vm_uiomove __P((vm_map_t, vm_object_t, off_t, int, vm_offset_t, int *));
-void vm_freeze_copyopts __P((vm_object_t, vm_pindex_t, vm_pindex_t));
-int vm_map_stack __P((vm_map_t, vm_offset_t, vm_size_t, vm_prot_t, vm_prot_t, int));
-int vm_map_growstack __P((struct proc *p, vm_offset_t addr));
-int vmspace_swap_count __P((struct vmspace *vmspace));
+vm_map_t vm_map_create (struct pmap *, vm_offset_t, vm_offset_t);
+int vm_map_delete (vm_map_t, vm_offset_t, vm_offset_t);
+int vm_map_find (vm_map_t, vm_object_t, vm_ooffset_t, vm_offset_t *, vm_size_t, boolean_t, vm_prot_t, vm_prot_t, int);
+int vm_map_findspace (vm_map_t, vm_offset_t, vm_size_t, vm_offset_t *);
+int vm_map_inherit (vm_map_t, vm_offset_t, vm_offset_t, vm_inherit_t);
+void vm_map_init (struct vm_map *, vm_offset_t, vm_offset_t);
+int vm_map_insert (vm_map_t, vm_object_t, vm_ooffset_t, vm_offset_t, vm_offset_t, vm_prot_t, vm_prot_t, int);
+int vm_map_lookup (vm_map_t *, vm_offset_t, vm_prot_t, vm_map_entry_t *, vm_object_t *,
+    vm_pindex_t *, vm_prot_t *, boolean_t *);
+void vm_map_lookup_done (vm_map_t, vm_map_entry_t);
+boolean_t vm_map_lookup_entry (vm_map_t, vm_offset_t, vm_map_entry_t *);
+int vm_map_pageable (vm_map_t, vm_offset_t, vm_offset_t, boolean_t);
+int vm_map_user_pageable (vm_map_t, vm_offset_t, vm_offset_t, boolean_t);
+int vm_map_clean (vm_map_t, vm_offset_t, vm_offset_t, boolean_t, boolean_t);
+int vm_map_protect (vm_map_t, vm_offset_t, vm_offset_t, vm_prot_t, boolean_t);
+int vm_map_remove (vm_map_t, vm_offset_t, vm_offset_t);
+void vm_map_startup (void);
+int vm_map_submap (vm_map_t, vm_offset_t, vm_offset_t, vm_map_t);
+int vm_map_madvise (vm_map_t, vm_offset_t, vm_offset_t, int);
+void vm_map_simplify_entry (vm_map_t, vm_map_entry_t);
+void vm_init2 (void);
+int vm_uiomove (vm_map_t, vm_object_t, off_t, int, vm_offset_t, int *);
+void vm_freeze_copyopts (vm_object_t, vm_pindex_t, vm_pindex_t);
+int vm_map_stack (vm_map_t, vm_offset_t, vm_size_t, vm_prot_t, vm_prot_t, int);
+int vm_map_growstack (struct proc *p, vm_offset_t addr);
+int vmspace_swap_count (struct vmspace *vmspace);
 
 #endif
 #endif                         /* _VM_MAP_ */
index 463e1b4..00d2d62 100644 (file)
@@ -39,7 +39,7 @@
  *
  *     @(#)vm_mmap.c   8.4 (Berkeley) 1/12/94
  * $FreeBSD: src/sys/vm/vm_mmap.c,v 1.108.2.6 2002/07/02 20:06:19 dillon Exp $
- * $DragonFly: src/sys/vm/vm_mmap.c,v 1.10 2003/07/30 00:19:16 dillon Exp $
+ * $DragonFly: src/sys/vm/vm_mmap.c,v 1.11 2003/08/20 08:03:01 rob Exp $
  */
 
 /*
@@ -92,7 +92,7 @@ SYSCTL_INT(_vm, OID_AUTO, max_proc_mmap, CTLFLAG_RW, &max_proc_mmap, 0, "");
  * multi-threaded processes are not unduly inconvenienced.
  */
 
-static void vmmapentry_rsrc_init __P((void *));
+static void vmmapentry_rsrc_init (void *);
 SYSINIT(vmmersrc, SI_SUB_KVM_RSRC, SI_ORDER_FIRST, vmmapentry_rsrc_init, NULL)
 
 static void
index 41db379..b4d9ea8 100644 (file)
@@ -62,7 +62,7 @@
  * rights to redistribute these changes.
  *
  * $FreeBSD: src/sys/vm/vm_object.c,v 1.171.2.8 2003/05/26 19:17:56 alc Exp $
- * $DragonFly: src/sys/vm/vm_object.c,v 1.6 2003/07/06 21:23:56 dillon Exp $
+ * $DragonFly: src/sys/vm/vm_object.c,v 1.7 2003/08/20 08:03:01 rob Exp $
  */
 
 /*
@@ -1726,9 +1726,9 @@ vm_object_set_writeable_dirty(vm_object_t object)
 
 #include <ddb/ddb.h>
 
-static int     _vm_object_in_map __P((vm_map_t map, vm_object_t object,
-                                      vm_map_entry_t entry));
-static int     vm_object_in_map __P((vm_object_t object));
+static int     _vm_object_in_map (vm_map_t map, vm_object_t object,
+                                      vm_map_entry_t entry);
+static int     vm_object_in_map (vm_object_t object);
 
 static int
 _vm_object_in_map(map, object, entry)
index d882e50..8a31b98 100644 (file)
@@ -62,7 +62,7 @@
  * rights to redistribute these changes.
  *
  * $FreeBSD: src/sys/vm/vm_object.h,v 1.63.2.3 2003/05/26 19:17:56 alc Exp $
- * $DragonFly: src/sys/vm/vm_object.h,v 1.3 2003/07/19 21:14:53 dillon Exp $
+ * $DragonFly: src/sys/vm/vm_object.h,v 1.4 2003/08/20 08:03:01 rob Exp $
  */
 
 /*
@@ -250,24 +250,24 @@ vm_object_pip_wait(vm_object_t object, char *waitid)
                vm_object_pip_sleep(object, waitid);
 }
 
-vm_object_t vm_object_allocate __P((objtype_t, vm_size_t));
-void _vm_object_allocate __P((objtype_t, vm_size_t, vm_object_t));
-boolean_t vm_object_coalesce __P((vm_object_t, vm_pindex_t, vm_size_t, vm_size_t));
-void vm_object_collapse __P((vm_object_t));
-void vm_object_deallocate __P((vm_object_t));
-void vm_object_terminate __P((vm_object_t));
-void vm_object_vndeallocate __P((vm_object_t));
-void vm_object_set_writeable_dirty __P((vm_object_t));
-void vm_object_init __P((void));
-void vm_object_page_clean __P((vm_object_t, vm_pindex_t, vm_pindex_t, boolean_t));
-void vm_object_page_remove __P((vm_object_t, vm_pindex_t, vm_pindex_t, boolean_t));
-void vm_object_pmap_copy __P((vm_object_t, vm_pindex_t, vm_pindex_t));
-void vm_object_pmap_copy_1 __P((vm_object_t, vm_pindex_t, vm_pindex_t));
-void vm_object_pmap_remove __P((vm_object_t, vm_pindex_t, vm_pindex_t));
-void vm_object_reference __P((vm_object_t));
-void vm_object_shadow __P((vm_object_t *, vm_ooffset_t *, vm_size_t));
-void vm_object_madvise __P((vm_object_t, vm_pindex_t, int, int));
-void vm_object_init2 __P((void));
+vm_object_t vm_object_allocate (objtype_t, vm_size_t);
+void _vm_object_allocate (objtype_t, vm_size_t, vm_object_t);
+boolean_t vm_object_coalesce (vm_object_t, vm_pindex_t, vm_size_t, vm_size_t);
+void vm_object_collapse (vm_object_t);
+void vm_object_deallocate (vm_object_t);
+void vm_object_terminate (vm_object_t);
+void vm_object_vndeallocate (vm_object_t);
+void vm_object_set_writeable_dirty (vm_object_t);
+void vm_object_init (void);
+void vm_object_page_clean (vm_object_t, vm_pindex_t, vm_pindex_t, boolean_t);
+void vm_object_page_remove (vm_object_t, vm_pindex_t, vm_pindex_t, boolean_t);
+void vm_object_pmap_copy (vm_object_t, vm_pindex_t, vm_pindex_t);
+void vm_object_pmap_copy_1 (vm_object_t, vm_pindex_t, vm_pindex_t);
+void vm_object_pmap_remove (vm_object_t, vm_pindex_t, vm_pindex_t);
+void vm_object_reference (vm_object_t);
+void vm_object_shadow (vm_object_t *, vm_ooffset_t *, vm_size_t);
+void vm_object_madvise (vm_object_t, vm_pindex_t, int, int);
+void vm_object_init2 (void);
 #endif                         /* _KERNEL */
 
 #endif                         /* _VM_OBJECT_ */
index 4c58a2e..33c3cd4 100644 (file)
@@ -66,7 +66,7 @@
  * rights to redistribute these changes.
  *
  * $FreeBSD: src/sys/vm/vm_pageout.c,v 1.151.2.15 2002/12/29 18:21:04 dillon Exp $
- * $DragonFly: src/sys/vm/vm_pageout.c,v 1.7 2003/07/26 22:10:02 rob Exp $
+ * $DragonFly: src/sys/vm/vm_pageout.c,v 1.8 2003/08/20 08:03:01 rob Exp $
  */
 
 /*
  */
 
 /* the kernel process "vm_pageout"*/
-static void vm_pageout __P((void));
-static int vm_pageout_clean __P((vm_page_t));
-static void vm_pageout_scan __P((int pass));
-static int vm_pageout_free_page_calc __P((vm_size_t count));
+static void vm_pageout (void);
+static int vm_pageout_clean (vm_page_t);
+static void vm_pageout_scan (int pass);
+static int vm_pageout_free_page_calc (vm_size_t count);
 struct thread *pagethread;
 
 static struct kproc_desc page_kp = {
@@ -117,7 +117,7 @@ SYSINIT(pagedaemon, SI_SUB_KTHREAD_PAGE, SI_ORDER_FIRST, kproc_start, &page_kp)
 
 #if !defined(NO_SWAPPING)
 /* the kernel process "vm_daemon"*/
-static void vm_daemon __P((void));
+static void vm_daemon (void);
 static struct  thread *vmthread;
 
 static struct kproc_desc vm_kp = {
@@ -199,10 +199,10 @@ int vm_pageout_page_count = VM_PAGEOUT_PAGE_COUNT;
 int vm_page_max_wired;         /* XXX max # of wired pages system-wide */
 
 #if !defined(NO_SWAPPING)
-typedef void freeer_fcn_t __P((vm_map_t, vm_object_t, vm_pindex_t, int));
-static void vm_pageout_map_deactivate_pages __P((vm_map_t, vm_pindex_t));
+typedef void freeer_fcn_t (vm_map_t, vm_object_t, vm_pindex_t, int);
+static void vm_pageout_map_deactivate_pages (vm_map_t, vm_pindex_t);
 static freeer_fcn_t vm_pageout_object_deactivate_pages;
-static void vm_req_vmdaemon __P((void));
+static void vm_req_vmdaemon (void);
 #endif
 static void vm_pageout_page_stats(void);
 
index 5439f9f..fc9d4ff 100644 (file)
@@ -62,7 +62,7 @@
  * rights to redistribute these changes.
  *
  * $FreeBSD: src/sys/vm/vm_pageout.h,v 1.26.2.1 2002/02/26 05:49:28 silby Exp $
- * $DragonFly: src/sys/vm/vm_pageout.h,v 1.3 2003/06/21 07:54:57 dillon Exp $
+ * $DragonFly: src/sys/vm/vm_pageout.h,v 1.4 2003/08/20 08:03:01 rob Exp $
  */
 
 #ifndef _VM_VM_PAGEOUT_H_
@@ -99,17 +99,17 @@ extern int vm_pageout_deficit;
  *     Signal pageout-daemon and wait for it.
  */
 
-extern void pagedaemon_wakeup __P((void));
+extern void pagedaemon_wakeup (void);
 #define VM_WAIT vm_wait()
 #define VM_WAITPFAULT vm_waitpfault()
-extern void vm_wait __P((void));
-extern void vm_waitpfault __P((void));
+extern void vm_wait (void);
+extern void vm_waitpfault (void);
 
 #ifdef _KERNEL
-void vm_pageout_page __P((vm_page_t, vm_object_t));
-void vm_pageout_cluster __P((vm_page_t, vm_object_t));
-int vm_pageout_flush __P((vm_page_t *, int, int));
-void vm_pageout_page_free __P((vm_page_t));
+void vm_pageout_page (vm_page_t, vm_object_t);
+void vm_pageout_cluster (vm_page_t, vm_object_t);
+int vm_pageout_flush (vm_page_t *, int, int);
+void vm_pageout_page_free (vm_page_t);
 
 #endif
 
index afdeab3..c0d5954 100644 (file)
@@ -62,7 +62,7 @@
  * rights to redistribute these changes.
  *
  * $FreeBSD: src/sys/vm/vm_pager.c,v 1.54.2.2 2001/11/18 07:11:00 dillon Exp $
- * $DragonFly: src/sys/vm/vm_pager.c,v 1.7 2003/07/26 22:10:03 rob Exp $
+ * $DragonFly: src/sys/vm/vm_pager.c,v 1.8 2003/08/20 08:03:01 rob Exp $
  */
 
 /*
@@ -98,12 +98,12 @@ extern struct pagerops physpagerops;
 
 int cluster_pbuf_freecnt = -1; /* unlimited to begin with */
 
-static int dead_pager_getpages __P((vm_object_t, vm_page_t *, int, int));
-static vm_object_t dead_pager_alloc __P((void *, vm_ooffset_t, vm_prot_t,
-       vm_ooffset_t));
-static void dead_pager_putpages __P((vm_object_t, vm_page_t *, int, int, int *));
-static boolean_t dead_pager_haspage __P((vm_object_t, vm_pindex_t, int *, int *));
-static void dead_pager_dealloc __P((vm_object_t));
+static int dead_pager_getpages (vm_object_t, vm_page_t *, int, int);
+static vm_object_t dead_pager_alloc (void *, vm_ooffset_t, vm_prot_t,
+       vm_ooffset_t);
+static void dead_pager_putpages (vm_object_t, vm_page_t *, int, int, int *);
+static boolean_t dead_pager_haspage (vm_object_t, vm_pindex_t, int *, int *);
+static void dead_pager_dealloc (vm_object_t);
 
 static int
 dead_pager_getpages(obj, ma, count, req)
index 7196b9d..fb0bd2a 100644 (file)
@@ -37,7 +37,7 @@
  *
  *     @(#)vm_pager.h  8.4 (Berkeley) 1/12/94
  * $FreeBSD: src/sys/vm/vm_pager.h,v 1.24.2.2 2002/12/31 09:34:51 dillon Exp $
- * $DragonFly: src/sys/vm/vm_pager.h,v 1.2 2003/06/17 04:29:00 dillon Exp $
+ * $DragonFly: src/sys/vm/vm_pager.h,v 1.3 2003/08/20 08:03:01 rob Exp $
  */
 
 /*
@@ -54,14 +54,14 @@ TAILQ_HEAD(pagerlst, vm_object);
 struct buf;
 
 struct pagerops {
-       void (*pgo_init) __P((void));           /* Initialize pager. */
-       vm_object_t (*pgo_alloc) __P((void *, vm_ooffset_t, vm_prot_t, vm_ooffset_t));  /* Allocate pager. */
-       void (*pgo_dealloc) __P((vm_object_t)); /* Disassociate. */
-       int (*pgo_getpages) __P((vm_object_t, vm_page_t *, int, int));  /* Get (read) page. */
-       void (*pgo_putpages) __P((vm_object_t, vm_page_t *, int, int, int *)); /* Put (write) page. */
-       boolean_t (*pgo_haspage) __P((vm_object_t, vm_pindex_t, int *, int *)); /* Does pager have page? */
-       void (*pgo_pageunswapped) __P((vm_page_t));
-       void (*pgo_strategy) __P((vm_object_t, struct buf *));
+       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. */
+       int (*pgo_getpages) (vm_object_t, vm_page_t *, int, int);       /* Get (read) page. */
+       void (*pgo_putpages) (vm_object_t, vm_page_t *, int, int, int *); /* Put (write) page. */
+       boolean_t (*pgo_haspage) (vm_object_t, vm_pindex_t, int *, int *); /* Does pager have page? */
+       void (*pgo_pageunswapped) (vm_page_t);
+       void (*pgo_strategy) (vm_object_t, struct buf *);
 };
 
 /*
@@ -95,19 +95,19 @@ extern vm_map_t pager_map;
 extern int pager_map_size;
 extern struct pagerops *pagertab[];
 
-vm_object_t vm_pager_allocate __P((objtype_t, void *, vm_ooffset_t, vm_prot_t, vm_ooffset_t));
-void vm_pager_bufferinit __P((void));
-void vm_pager_deallocate __P((vm_object_t));
-static __inline int vm_pager_get_pages __P((vm_object_t, vm_page_t *, int, int));
-static __inline boolean_t vm_pager_has_page __P((vm_object_t, vm_pindex_t, int *, int *));
-void vm_pager_init __P((void));
-vm_object_t vm_pager_object_lookup __P((struct pagerlst *, void *));
-vm_offset_t vm_pager_map_pages __P((vm_page_t *, int, boolean_t));
-vm_offset_t vm_pager_map_page __P((vm_page_t));
-void vm_pager_sync __P((void));
-void vm_pager_unmap_pages __P((vm_offset_t, int));
-void vm_pager_unmap_page __P((vm_offset_t));
-void vm_pager_strategy __P((vm_object_t object, struct buf *bp));
+vm_object_t vm_pager_allocate (objtype_t, void *, vm_ooffset_t, vm_prot_t, vm_ooffset_t);
+void vm_pager_bufferinit (void);
+void vm_pager_deallocate (vm_object_t);
+static __inline int vm_pager_get_pages (vm_object_t, vm_page_t *, int, int);
+static __inline boolean_t vm_pager_has_page (vm_object_t, vm_pindex_t, int *, int *);
+void vm_pager_init (void);
+vm_object_t vm_pager_object_lookup (struct pagerlst *, void *);
+vm_offset_t vm_pager_map_pages (vm_page_t *, int, boolean_t);
+vm_offset_t vm_pager_map_page (vm_page_t);
+void vm_pager_sync (void);
+void vm_pager_unmap_pages (vm_offset_t, int);
+void vm_pager_unmap_page (vm_offset_t);
+void vm_pager_strategy (vm_object_t object, struct buf *bp);
 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);
index 9b7473b..43c7c23 100644 (file)
@@ -32,7 +32,7 @@
  *
  *     @(#)vm_swap.c   8.5 (Berkeley) 2/17/94
  * $FreeBSD: src/sys/vm/vm_swap.c,v 1.96.2.2 2001/10/14 18:46:47 iedowse Exp $
- * $DragonFly: src/sys/vm/vm_swap.c,v 1.7 2003/07/26 22:10:03 rob Exp $
+ * $DragonFly: src/sys/vm/vm_swap.c,v 1.8 2003/08/20 08:03:01 rob Exp $
  */
 
 #include "opt_swap.h"
@@ -69,7 +69,7 @@ static int nswap;             /* first block after the interleaved devs */
 static int nswdev = NSWAPDEV;
 int vm_swap_size;
 
-static int swapdev_strategy __P((struct vop_strategy_args *ap));
+static int swapdev_strategy (struct vop_strategy_args *ap);
 struct vnode *swapdev_vp;
 
 /*
index f687683..09f3a6f 100644 (file)
@@ -12,7 +12,7 @@
  *     John S. Dyson.
  *
  * $FreeBSD: src/sys/vm/vm_zone.h,v 1.13.2.2 2002/10/10 19:50:16 dillon Exp $
- * $DragonFly: src/sys/vm/vm_zone.h,v 1.3 2003/07/06 21:23:56 dillon Exp $
+ * $DragonFly: src/sys/vm/vm_zone.h,v 1.4 2003/08/20 08:03:01 rob Exp $
  */
 
 #ifndef _SYS_ZONE_H
@@ -50,14 +50,14 @@ typedef struct vm_zone {
 } *vm_zone_t;
 
 
-void           zerror __P((int)) __dead2;
-vm_zone_t      zinit __P((char *name, int size, int nentries, int flags,
-                          int zalloc));
-int            zinitna __P((vm_zone_t z, struct vm_object *obj, char *name,
-                            int size, int nentries, int flags, int zalloc));
-void *         zalloc __P((vm_zone_t z));
-void           zfree __P((vm_zone_t z, void *item));
-void           zbootinit __P((vm_zone_t z, char *name, int size, void *item,
-                              int nitems));
+void           zerror (int) __dead2;
+vm_zone_t      zinit (char *name, int size, int nentries, int flags,
+                          int zalloc);
+int            zinitna (vm_zone_t z, struct vm_object *obj, char *name,
+                            int size, int nentries, int flags, int zalloc);
+void *         zalloc (vm_zone_t z);
+void           zfree (vm_zone_t z, void *item);
+void           zbootinit (vm_zone_t z, char *name, int size, void *item,
+                              int nitems);
 
 #endif /* _SYS_ZONE_H */
index b6f73ba..0bdaf07 100644 (file)
@@ -39,7 +39,7 @@
  *
  *     from: @(#)vnode_pager.c 7.5 (Berkeley) 4/20/91
  * $FreeBSD: src/sys/vm/vnode_pager.c,v 1.116.2.7 2002/12/31 09:34:51 dillon Exp $
- * $DragonFly: src/sys/vm/vnode_pager.c,v 1.9 2003/07/26 22:10:03 rob Exp $
+ * $DragonFly: src/sys/vm/vnode_pager.c,v 1.10 2003/08/20 08:03:01 rob Exp $
  */
 
 /*
 #include <vm/vnode_pager.h>
 #include <vm/vm_extern.h>
 
-static vm_offset_t vnode_pager_addr __P((struct vnode *vp, vm_ooffset_t address,
-                                        int *run));
-static void vnode_pager_iodone __P((struct buf *bp));
-static int vnode_pager_input_smlfs __P((vm_object_t object, vm_page_t m));
-static int vnode_pager_input_old __P((vm_object_t object, vm_page_t m));
-static void vnode_pager_dealloc __P((vm_object_t));
-static int vnode_pager_getpages __P((vm_object_t, vm_page_t *, int, int));
-static void vnode_pager_putpages __P((vm_object_t, vm_page_t *, int, boolean_t, int *));
-static boolean_t vnode_pager_haspage __P((vm_object_t, vm_pindex_t, int *, int *));
+static vm_offset_t vnode_pager_addr (struct vnode *vp, vm_ooffset_t address,
+                                        int *run);
+static void vnode_pager_iodone (struct buf *bp);
+static int vnode_pager_input_smlfs (vm_object_t object, vm_page_t m);
+static int vnode_pager_input_old (vm_object_t object, vm_page_t m);
+static void vnode_pager_dealloc (vm_object_t);
+static int vnode_pager_getpages (vm_object_t, vm_page_t *, int, int);
+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, int *, int *);
 
 struct pagerops vnodepagerops = {
        NULL,
index 5f196cd..3538ed4 100644 (file)
  *
  *     @(#)vnode_pager.h       8.1 (Berkeley) 6/11/93
  * $FreeBSD: src/sys/vm/vnode_pager.h,v 1.14 1999/12/29 04:55:12 peter Exp $
- * $DragonFly: src/sys/vm/vnode_pager.h,v 1.2 2003/06/17 04:29:00 dillon Exp $
+ * $DragonFly: src/sys/vm/vnode_pager.h,v 1.3 2003/08/20 08:03:01 rob Exp $
  */
 
 #ifndef        _VNODE_PAGER_
 #define        _VNODE_PAGER_   1
 
 #ifdef _KERNEL
-vm_object_t vnode_pager_alloc __P((void *, vm_ooffset_t, vm_prot_t, vm_ooffset_t));
-void vnode_pager_freepage __P((vm_page_t m));
-struct vnode *vnode_pager_lock __P((vm_object_t));
+vm_object_t vnode_pager_alloc (void *, vm_ooffset_t, vm_prot_t, vm_ooffset_t);
+void vnode_pager_freepage (vm_page_t m);
+struct vnode *vnode_pager_lock (vm_object_t);
 
 /*
  * XXX Generic routines; currently called by badly written FS code; these
  * XXX should go away soon.
  */
-int vnode_pager_generic_getpages __P((struct vnode *vp, vm_page_t *m,
-                                         int count, int reqpage));
-int vnode_pager_generic_putpages __P((struct vnode *vp, vm_page_t *m,
+int vnode_pager_generic_getpages (struct vnode *vp, vm_page_t *m,
+                                         int count, int reqpage);
+int vnode_pager_generic_putpages (struct vnode *vp, vm_page_t *m,
                                          int count, boolean_t sync,
-                                         int *rtvals));
+                                         int *rtvals);
 #endif
 
 #endif                         /* _VNODE_PAGER_ */