Remove __P.

17 files changed, 209 insertions, 213 deletions

diff --git a/sys/vm/default_pager.c b/sys/vm/default_pager.c
index 305c011..c3854ab 100644
--- a/sys/vm/default_pager.c
+++ b/sys/vm/default_pager.c
@@ -52,14 +52,14 @@
 #include <vm/vm_zone.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".
  */
diff --git a/sys/vm/device_pager.c b/sys/vm/device_pager.c
index bf6b3d9..e4e5591 100644
--- a/sys/vm/device_pager.c
+++ b/sys/vm/device_pager.c
@@ -54,15 +54,15 @@
 #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;
@@ -77,8 +77,8 @@ static vm_zone_t fakepg_zone;
 static struct vm_zone fakepg_zone_store;
 #endif
 
-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);
 
 struct pagerops devicepagerops = {
 	dev_pager_init,
diff --git a/sys/vm/pmap.h b/sys/vm/pmap.h
index 9c91d3e..4edb3da 100644
--- a/sys/vm/pmap.h
+++ b/sys/vm/pmap.h
@@ -90,60 +90,57 @@ 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_new_proc __P((struct proc *p));
-void		 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_new_thread __P((struct thread *td));
-void		 pmap_dispose_thread __P((struct thread *td));
-void		 pmap_swapout_thread __P((struct thread *td));
-void		 pmap_swapin_thread __P((struct thread *td));
-void		 pmap_activate __P((struct thread *td));
-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_new_proc(struct proc *p);
+void		 pmap_dispose_proc(struct proc *p);
+void		 pmap_swapout_proc(struct proc *p);
+void		 pmap_swapin_proc(struct proc *p);
+void		 pmap_new_thread(struct thread *td);
+void		 pmap_dispose_thread(struct thread *td);
+void		 pmap_swapout_thread(struct thread *td);
+void		 pmap_swapin_thread(struct thread *td);
+void		 pmap_activate(struct thread *td);
+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 */
 #endif /* _PMAP_VM_ */
diff --git a/sys/vm/swap_pager.c b/sys/vm/swap_pager.c
index 7b9c49a..a6552d9 100644
--- a/sys/vm/swap_pager.c
+++ b/sys/vm/swap_pager.c
@@ -156,13 +156,13 @@ vm_zone_t		swap_zone;
  * (see vm/swap_pager.h).
  */
 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 bio *));
+		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 bio *);
 
 struct pagerops swappagerops = {
 	swap_pager_init,	/* early system initialization of pager	*/
@@ -194,23 +194,23 @@ int nswap_hiwat = 512;		/* in pages, swap_pager_almost_full warn */
 SYSCTL_INT(_vm, OID_AUTO, dmmax,
 	CTLFLAG_RD, &dmmax, 0, "Maximum size of a swap block");
 
-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
diff --git a/sys/vm/swap_pager.h b/sys/vm/swap_pager.h
index c71eb98..b028ecb 100644
--- a/sys/vm/swap_pager.h
+++ b/sys/vm/swap_pager.h
@@ -84,25 +84,25 @@ extern int swap_pager_full;
 extern struct blist *swapblist;
 extern vm_zone_t swap_zone;
 
-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				/* _KERNEL */
 #endif				/* _SWAP_PAGER_ */
diff --git a/sys/vm/vm_extern.h b/sys/vm/vm_extern.h
index 0f5f92d..cfe8fac 100644
--- a/sys/vm/vm_extern.h
+++ b/sys/vm/vm_extern.h
@@ -47,55 +47,55 @@ struct vnode;
 #ifdef _KERNEL
 
 #ifdef TYPEDEF_FOR_UAP
-int getpagesize __P((struct thread *, void *, int *));
-int madvise __P((struct thread *, void *, int *));
-int mincore __P((struct thread *, void *, int *));
-int mprotect __P((struct thread *, void *, int *));
-int msync __P((struct thread *, void *, int *));
-int munmap __P((struct thread *, void *, int *));
-int obreak __P((struct thread *, void *, int *));
-int sbrk __P((struct thread *, void *, int *));
-int sstk __P((struct thread *, void *, int *));
-int swapon __P((struct thread *, void *, int *));
+int getpagesize(struct thread *, void *, int *);
+int madvise(struct thread *, void *, int *);
+int mincore(struct thread *, void *, int *);
+int mprotect(struct thread *, void *, int *);
+int msync(struct thread *, void *, int *);
+int munmap(struct thread *, void *, int *);
+int obreak(struct thread *, void *, int *);
+int sbrk(struct thread *, void *, int *);
+int sstk(struct thread *, void *, int *);
+int swapon(struct thread *, void *, int *);
 #endif			/* TYPEDEF_FOR_UAP */
 
-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 thread *, 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_forkproc __P((struct thread *, struct proc *, struct thread *, 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 thread *, 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_forkproc(struct thread *, struct proc *, struct thread *, 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 */
 #endif				/* !_VM_EXTERN_H_ */
diff --git a/sys/vm/vm_fault.c b/sys/vm/vm_fault.c
index 051e48e..3466360 100644
--- a/sys/vm/vm_fault.c
+++ b/sys/vm/vm_fault.c
@@ -95,8 +95,7 @@
 #include <vm/vnode_pager.h>
 #include <vm/vm_extern.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
@@ -182,7 +181,7 @@ _unlock_things(struct faultstate *fs, int dealloc)
  *	The map in question must be referenced, and remains so.
  *	Caller may hold no locks.
  */
-static int vm_fault1 __P((vm_map_t, vm_offset_t, vm_prot_t, int));
+static int vm_fault1(vm_map_t, vm_offset_t, vm_prot_t, int);
 
 int
 vm_fault(vm_map_t map, vm_offset_t vaddr, vm_prot_t fault_type,
diff --git a/sys/vm/vm_glue.c b/sys/vm/vm_glue.c
index 9f931a1..2adbb4a 100644
--- a/sys/vm/vm_glue.c
+++ b/sys/vm/vm_glue.c
@@ -99,7 +99,7 @@ extern int maxslp;
  *
  * 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)
 
 /*
@@ -107,11 +107,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)
 
 #ifndef NO_SWAPPING
-static void swapout __P((struct proc *));
+static void swapout(struct proc *);
 #endif
 
 int
diff --git a/sys/vm/vm_init.c b/sys/vm/vm_init.c
index 5114470..7230855 100644
--- a/sys/vm/vm_init.c
+++ b/sys/vm/vm_init.c
@@ -90,7 +90,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)
 
 /*
diff --git a/sys/vm/vm_mmap.c b/sys/vm/vm_mmap.c
index 0a75a9d..603ce6e 100644
--- a/sys/vm/vm_mmap.c
+++ b/sys/vm/vm_mmap.c
@@ -93,7 +93,7 @@ SYSCTL_INT(_vm, OID_AUTO, max_proc_mmap, CTLFLAG_RW, &max_proc_mmap, 0, "");
  * if attacked from compromised user account but generous enough such that
  * 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
diff --git a/sys/vm/vm_pageout.c b/sys/vm/vm_pageout.c
index c4b94de..3489cc3 100644
--- a/sys/vm/vm_pageout.c
+++ b/sys/vm/vm_pageout.c
@@ -106,10 +106,10 @@
  */
 
 /* 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 proc *pageproc;
 
 static struct kproc_desc page_kp = {
@@ -121,7 +121,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	proc *vmproc;
 
 static struct kproc_desc vm_kp = {
@@ -203,10 +203,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);
 
diff --git a/sys/vm/vm_pageout.h b/sys/vm/vm_pageout.h
index d78537d..c909c68 100644
--- a/sys/vm/vm_pageout.h
+++ b/sys/vm/vm_pageout.h
@@ -98,16 +98,16 @@ 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
 #endif	/* _VM_VM_PAGEOUT_H_ */
diff --git a/sys/vm/vm_pager.c b/sys/vm/vm_pager.c
index 60f7e72..c3cbbc7 100644
--- a/sys/vm/vm_pager.c
+++ b/sys/vm/vm_pager.c
@@ -95,12 +95,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)
diff --git a/sys/vm/vm_pager.h b/sys/vm/vm_pager.h
index df0a508..66fe080 100644
--- a/sys/vm/vm_pager.h
+++ b/sys/vm/vm_pager.h
@@ -53,14 +53,14 @@ TAILQ_HEAD(pagerlst, vm_object);
 struct bio;
 
 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 bio *));
+	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 bio *);
 };
 
 /*
@@ -92,19 +92,19 @@ extern int pager_map_size;
 extern struct pagerops *pagertab[];
 extern struct mtx pbuf_mtx;
 
-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 bio *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 bio *bp);
 
 /*
  *	vm_page_get_pages:
diff --git a/sys/vm/vm_swap.c b/sys/vm/vm_swap.c
index 48741af..a79a8e2 100644
--- a/sys/vm/vm_swap.c
+++ b/sys/vm/vm_swap.c
@@ -71,7 +71,7 @@ static int nswap;		/* first block after the interleaved devs */
 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;
 
 /*
diff --git a/sys/vm/vnode_pager.c b/sys/vm/vnode_pager.c
index 85d04e4..f069b6a 100644
--- a/sys/vm/vnode_pager.c
+++ b/sys/vm/vnode_pager.c
@@ -69,16 +69,16 @@
 #include <vm/vnode_pager.h>
 #include <vm/vm_extern.h>
 
-static void vnode_pager_init __P((void));
-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 void vnode_pager_init(void);
+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 = {
 	vnode_pager_init,
diff --git a/sys/vm/vnode_pager.h b/sys/vm/vnode_pager.h
index 63f2d62..820d87e 100644
--- a/sys/vm/vnode_pager.h
+++ b/sys/vm/vnode_pager.h
@@ -43,17 +43,17 @@
 #define	_VNODE_PAGER_	1
 
 #ifdef _KERNEL
-vm_object_t vnode_pager_alloc __P((void *, vm_ooffset_t, vm_prot_t, vm_ooffset_t));
-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);
+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				/* _KERNEL */
 #endif				/* _VNODE_PAGER_ */