Remove __P

80 files changed, 1406 insertions, 1417 deletions

diff --git a/sys/sys/_sigset.h b/sys/sys/_sigset.h
index b1ae12b..c658e28 100644
--- a/sys/sys/_sigset.h
+++ b/sys/sys/_sigset.h
@@ -119,7 +119,7 @@
  * have the same calling protocol so there is no problem in practice.
  * A bit in sa_flags could be used to specify the number of args.
  */
-typedef void __sighandler_t __P((int));
+typedef void __sighandler_t(int);
 
 #define	SIG_DFL		((__sighandler_t *)0)
 #define	SIG_IGN		((__sighandler_t *)1)
@@ -186,9 +186,8 @@ struct __siginfo;
  */
 struct sigaction {
 	union {
-		void    (*__sa_handler) __P((int));
-		void    (*__sa_sigaction) __P((int, struct __siginfo *,
-					       void *));
+		void    (*__sa_handler)(int);
+		void    (*__sa_sigaction)(int, struct __siginfo *, void *);
 	} __sigaction_u;		/* signal handler */
 	int	sa_flags;		/* see signal options below */
 	sigset_t sa_mask;		/* signal mask to apply */
@@ -225,7 +224,7 @@ struct sigaction {
 /* Additional FreeBSD values. */
 #define SI_UNDEFINED	0
 
-typedef void __siginfohandler_t __P((int, struct __siginfo *, void *));
+typedef void __siginfohandler_t(int, struct __siginfo *, void *);
 
 typedef	__sighandler_t	*sig_t;	/* type of pointer to a signal function */
 
@@ -303,7 +302,7 @@ struct sigstack {
  * defined by <sys/signal.h>.
  */
 __BEGIN_DECLS
-__sighandler_t *signal __P((int, __sighandler_t *));
+__sighandler_t *signal(int, __sighandler_t *);
 __END_DECLS
 
 #endif	/* !_SYS_SIGNAL_H_ */
diff --git a/sys/sys/acct.h b/sys/sys/acct.h
index 114b609..8e1b294 100644
--- a/sys/sys/acct.h
+++ b/sys/sys/acct.h
@@ -87,7 +87,7 @@ struct acct {
 #ifdef _KERNEL
 struct thread;
 
-int	acct_process __P((struct thread *td));
+int	acct_process(struct thread *td);
 #endif
 
 #endif /* !_SYS_ACCT_H_ */
diff --git a/sys/sys/acl.h b/sys/sys/acl.h
index 6133008..6d27e40 100644
--- a/sys/sys/acl.h
+++ b/sys/sys/acl.h
@@ -123,11 +123,11 @@ typedef struct acl_t_struct *acl_t;
 MALLOC_DECLARE(M_ACL);
 #endif
 
-acl_perm_t	acl_posix1e_mode_to_perm __P((acl_tag_t tag, mode_t mode));
-struct acl_entry	acl_posix1e_mode_to_entry __P((acl_tag_t tag, uid_t uid,
-    gid_t gid, mode_t mode));
-mode_t	acl_posix1e_perms_to_mode __P((struct acl_entry *acl_user_obj_entry,
-    struct acl_entry *acl_group_obj_entry, struct acl_entry *acl_other_entry));
+acl_perm_t	acl_posix1e_mode_to_perm(acl_tag_t tag, mode_t mode);
+struct acl_entry	acl_posix1e_mode_to_entry(acl_tag_t tag, uid_t uid,
+    gid_t gid, mode_t mode);
+mode_t	acl_posix1e_perms_to_mode(struct acl_entry *acl_user_obj_entry,
+    struct acl_entry *acl_group_obj_entry, struct acl_entry *acl_other_entry);
 int	acl_posix1e_check(struct acl *acl);
 
 #else /* !_KERNEL */
diff --git a/sys/sys/bio.h b/sys/sys/bio.h
index c5b8ba2..06c5ef8 100644
--- a/sys/sys/bio.h
+++ b/sys/sys/bio.h
@@ -51,7 +51,7 @@ struct g_provider;
 
 struct iodone_chain {
 	long	ic_prev_flags;
-	void	(*ic_prev_iodone) __P((struct bio *));
+	void	(*ic_prev_iodone)(struct bio *);
 	void	*ic_prev_iodone_chain;
 	struct {
 		long	ia_long;
@@ -73,7 +73,7 @@ struct bio {
 	struct buf	*_bio_buf;	/* Parent buffer. */
 	int	bio_error;		/* Errno for BIO_ERROR. */
 	long	bio_resid;		/* Remaining I/0 in bytes. */
-	void	(*bio_done) __P((struct bio *));
+	void	(*bio_done)(struct bio *);
 	void	*bio_driver1;		/* Private use by the callee. */
 	void	*bio_driver2;		/* Private use by the callee. */
 	void	*bio_caller1;		/* Private use by the caller. */
@@ -142,12 +142,12 @@ struct bio_queue_head {
 	int busy;
 };
 
-static __inline void bioq_init __P((struct bio_queue_head *head));
-static __inline void bioq_insert_tail __P((struct bio_queue_head *head,
-					   struct bio *bp));
-static __inline void bioq_remove __P((struct bio_queue_head *head,
-				      struct bio *bp));
-static __inline struct bio *bioq_first __P((struct bio_queue_head *head));
+static __inline void bioq_init(struct bio_queue_head *head);
+static __inline void bioq_insert_tail(struct bio_queue_head *head,
+					   struct bio *bp);
+static __inline void bioq_remove(struct bio_queue_head *head,
+				      struct bio *bp);
+static __inline struct bio *bioq_first(struct bio_queue_head *head);
 
 static __inline void
 bioq_init(struct bio_queue_head *head)
@@ -195,7 +195,7 @@ bioq_first(struct bio_queue_head *head)
 	(bp)->bio_resid = 0;						\
 }
 
-int	physio __P((dev_t dev, struct uio *uio, int ioflag));
+int	physio(dev_t dev, struct uio *uio, int ioflag);
 #define physread physio
 #define physwrite physio
 
diff --git a/sys/sys/buf.h b/sys/sys/buf.h
index 2cfae96..ea05cca 100644
--- a/sys/sys/buf.h
+++ b/sys/sys/buf.h
@@ -62,16 +62,16 @@ LIST_HEAD(workhead, worklist);
  * to each buffer.
  */
 extern struct bio_ops {
-	void	(*io_start) __P((struct buf *));
-	void	(*io_complete) __P((struct buf *));
-	void	(*io_deallocate) __P((struct buf *));
-	void	(*io_movedeps) __P((struct buf *, struct buf *));
-	int	(*io_countdeps) __P((struct buf *, int));
+	void	(*io_start)(struct buf *);
+	void	(*io_complete)(struct buf *);
+	void	(*io_deallocate)(struct buf *);
+	void	(*io_movedeps)(struct buf *, struct buf *);
+	int	(*io_countdeps)(struct buf *, int);
 } bioops;
 
 struct buf_ops {
 	char	*bop_name;
-	int	(*bop_write) __P((struct buf *));
+	int	(*bop_write)(struct buf *);
 };
 
 extern struct buf_ops buf_ops_bio;
@@ -113,7 +113,7 @@ struct buf {
 	unsigned		b_magic;
 #define B_MAGIC_BIO	0x10b10b10
 #define B_MAGIC_NFS	0x67238234
-	void	(*b_iodone) __P((struct buf *));
+	void	(*b_iodone)(struct buf *);
 	off_t	b_offset;		/* Offset into file. */
 	LIST_ENTRY(buf) b_hash;		/* Hash chain. */
 	TAILQ_ENTRY(buf) b_vnbufs;	/* Buffer's associated vnode. */
@@ -268,7 +268,7 @@ extern const char *buf_wmesg;		/* Default buffer lock message */
  *
  * Get a lock sleeping non-interruptably until it becomes available.
  */
-static __inline int BUF_LOCK __P((struct buf *, int));
+static __inline int BUF_LOCK(struct buf *, int);
 static __inline int
 BUF_LOCK(struct buf *bp, int locktype)
 {
@@ -286,7 +286,7 @@ BUF_LOCK(struct buf *bp, int locktype)
 /*
  * Get a lock sleeping with specified interruptably and timeout.
  */
-static __inline int BUF_TIMELOCK __P((struct buf *, int, char *, int, int));
+static __inline int BUF_TIMELOCK(struct buf *, int, char *, int, int);
 static __inline int
 BUF_TIMELOCK(struct buf *bp, int locktype, char *wmesg, int catch, int timo)
 {
@@ -306,7 +306,7 @@ BUF_TIMELOCK(struct buf *bp, int locktype, char *wmesg, int catch, int timo)
  * Release a lock. Only the acquiring process may free the lock unless
  * it has been handed off to biodone.
  */
-static __inline void BUF_UNLOCK __P((struct buf *));
+static __inline void BUF_UNLOCK(struct buf *);
 static __inline void
 BUF_UNLOCK(struct buf *bp)
 {
@@ -334,7 +334,7 @@ do {						\
  * original owning process can no longer acquire it recursively, but must
  * wait until the I/O is completed and the lock has been freed by biodone.
  */
-static __inline void BUF_KERNPROC __P((struct buf *));
+static __inline void BUF_KERNPROC(struct buf *);
 static __inline void
 BUF_KERNPROC(struct buf *bp)
 {
@@ -349,7 +349,7 @@ BUF_KERNPROC(struct buf *bp)
 /*
  * Find out the number of references to a lock.
  */
-static __inline int BUF_REFCNT __P((struct buf *));
+static __inline int BUF_REFCNT(struct buf *);
 static __inline int
 BUF_REFCNT(struct buf *bp)
 {
@@ -459,54 +459,53 @@ extern int	nswbuf;			/* Number of swap I/O buffer headers. */
 
 struct uio;
 
-caddr_t	kern_vfs_bio_buffer_alloc __P((caddr_t v, int physmem_est));
-void	bufinit __P((void));
-void	bwillwrite __P((void));
-int	buf_dirty_count_severe __P((void));
-void	bremfree __P((struct buf *));
-int	bread __P((struct vnode *, daddr_t, int,
-	    struct ucred *, struct buf **));
-int	breadn __P((struct vnode *, daddr_t, int, daddr_t *, int *, int,
-	    struct ucred *, struct buf **));
-int	bwrite __P((struct buf *));
-void	bdwrite __P((struct buf *));
-void	bawrite __P((struct buf *));
-void	bdirty __P((struct buf *));
-void	bundirty __P((struct buf *));
-void	brelse __P((struct buf *));
-void	bqrelse __P((struct buf *));
-int	vfs_bio_awrite __P((struct buf *));
-struct buf *     getpbuf __P((int *));
-struct buf *incore __P((struct vnode *, daddr_t));
-struct buf *gbincore __P((struct vnode *, daddr_t));
-int	inmem __P((struct vnode *, daddr_t));
-struct buf *getblk __P((struct vnode *, daddr_t, int, int, int));
-struct buf *geteblk __P((int));
-int	bufwait __P((struct buf *));
-void	bufdone __P((struct buf *));
-void	bufdonebio __P((struct bio *));
-
-void	cluster_callback __P((struct buf *));
-int	cluster_read __P((struct vnode *, u_quad_t, daddr_t, long,
-	    struct ucred *, long, int, struct buf **));
-int	cluster_wbuild __P((struct vnode *, long, daddr_t, int));
-void	cluster_write __P((struct buf *, u_quad_t, int));
-void	vfs_bio_set_validclean __P((struct buf *, int base, int size));
-void	vfs_bio_clrbuf __P((struct buf *));
-void	vfs_busy_pages __P((struct buf *, int clear_modify));
-void	vfs_unbusy_pages __P((struct buf *));
-void	vwakeup __P((struct buf *));
-void	vmapbuf __P((struct buf *));
-void	vunmapbuf __P((struct buf *));
-void	relpbuf __P((struct buf *, int *));
-void	brelvp __P((struct buf *));
-void	bgetvp __P((struct vnode *, struct buf *));
-void	pbgetvp __P((struct vnode *, struct buf *));
-void	pbrelvp __P((struct buf *));
-int	allocbuf __P((struct buf *bp, int size));
-void	reassignbuf __P((struct buf *, struct vnode *));
-void	pbreassignbuf __P((struct buf *, struct vnode *));
-struct	buf *trypbuf __P((int *));
+caddr_t	kern_vfs_bio_buffer_alloc(caddr_t v, int physmem_est);
+void	bufinit(void);
+void	bwillwrite(void);
+int	buf_dirty_count_severe(void);
+void	bremfree(struct buf *);
+int	bread(struct vnode *, daddr_t, int, struct ucred *, struct buf **);
+int	breadn(struct vnode *, daddr_t, int, daddr_t *, int *, int,
+	    struct ucred *, struct buf **);
+int	bwrite(struct buf *);
+void	bdwrite(struct buf *);
+void	bawrite(struct buf *);
+void	bdirty(struct buf *);
+void	bundirty(struct buf *);
+void	brelse(struct buf *);
+void	bqrelse(struct buf *);
+int	vfs_bio_awrite(struct buf *);
+struct buf *     getpbuf(int *);
+struct buf *incore(struct vnode *, daddr_t);
+struct buf *gbincore(struct vnode *, daddr_t);
+int	inmem(struct vnode *, daddr_t);
+struct buf *getblk(struct vnode *, daddr_t, int, int, int);
+struct buf *geteblk(int);
+int	bufwait(struct buf *);
+void	bufdone(struct buf *);
+void	bufdonebio(struct bio *);
+
+void	cluster_callback(struct buf *);
+int	cluster_read(struct vnode *, u_quad_t, daddr_t, long,
+	    struct ucred *, long, int, struct buf **);
+int	cluster_wbuild(struct vnode *, long, daddr_t, int);
+void	cluster_write(struct buf *, u_quad_t, int);
+void	vfs_bio_set_validclean(struct buf *, int base, int size);
+void	vfs_bio_clrbuf(struct buf *);
+void	vfs_busy_pages(struct buf *, int clear_modify);
+void	vfs_unbusy_pages(struct buf *);
+void	vwakeup(struct buf *);
+void	vmapbuf(struct buf *);
+void	vunmapbuf(struct buf *);
+void	relpbuf(struct buf *, int *);
+void	brelvp(struct buf *);
+void	bgetvp(struct vnode *, struct buf *);
+void	pbgetvp(struct vnode *, struct buf *);
+void	pbrelvp(struct buf *);
+int	allocbuf(struct buf *bp, int size);
+void	reassignbuf(struct buf *, struct vnode *);
+void	pbreassignbuf(struct buf *, struct vnode *);
+struct	buf *trypbuf(int *);
 
 #endif /* _KERNEL */
 
diff --git a/sys/sys/callout.h b/sys/sys/callout.h
index d973375..cab6692 100644
--- a/sys/sys/callout.h
+++ b/sys/sys/callout.h
@@ -54,7 +54,7 @@ struct callout {
 	} c_links;
 	int	c_time;				/* ticks to the event */
 	void	*c_arg;				/* function argument */
-	void	(*c_func) __P((void *));	/* function to call */
+	void	(*c_func)(void *);	/* function to call */
 	int	c_flags;			/* state of this entry */
 };
 
@@ -77,10 +77,10 @@ extern struct mtx callout_lock;
 
 #define	callout_active(c)	((c)->c_flags & CALLOUT_ACTIVE)
 #define	callout_deactivate(c)	((c)->c_flags &= ~CALLOUT_ACTIVE)
-void	callout_init __P((struct callout *, int));
+void	callout_init(struct callout *, int);
 #define	callout_pending(c)	((c)->c_flags & CALLOUT_PENDING)
-void	callout_reset __P((struct callout *, int, void (*)(void *), void *));
-int	callout_stop __P((struct callout *));
+void	callout_reset(struct callout *, int, void (*)(void *), void *);
+int	callout_stop(struct callout *);
 
 #endif
 
diff --git a/sys/sys/conf.h b/sys/sys/conf.h
index f4e3dde..ed93cdf 100644
--- a/sys/sys/conf.h
+++ b/sys/sys/conf.h
@@ -134,31 +134,29 @@ struct knote;
 
 typedef struct thread d_thread_t;
 
-typedef int d_open_t __P((dev_t dev, int oflags, int devtype,
-			  struct thread *td));
-typedef int d_close_t __P((dev_t dev, int fflag, int devtype,
-			   struct thread *td));
-typedef void d_strategy_t __P((struct bio *bp));
-typedef int d_ioctl_t __P((dev_t dev, u_long cmd, caddr_t data,
-			   int fflag, struct thread *td));
-typedef int d_dump_t __P((dev_t dev));
-typedef int d_psize_t __P((dev_t dev));
-
-typedef int d_read_t __P((dev_t dev, struct uio *uio, int ioflag));
-typedef int d_write_t __P((dev_t dev, struct uio *uio, int ioflag));
-typedef int d_poll_t __P((dev_t dev, int events, struct thread *td));
-typedef int d_kqfilter_t __P((dev_t dev, struct knote *kn));
-typedef int d_mmap_t __P((dev_t dev, vm_offset_t offset, int nprot));
-
-typedef int l_open_t __P((dev_t dev, struct tty *tp));
-typedef int l_close_t __P((struct tty *tp, int flag));
-typedef int l_read_t __P((struct tty *tp, struct uio *uio, int flag));
-typedef int l_write_t __P((struct tty *tp, struct uio *uio, int flag));
-typedef int l_ioctl_t __P((struct tty *tp, u_long cmd, caddr_t data,
-			   int flag, struct thread*td));
-typedef int l_rint_t __P((int c, struct tty *tp));
-typedef int l_start_t __P((struct tty *tp));
-typedef int l_modem_t __P((struct tty *tp, int flag));
+typedef int d_open_t(dev_t dev, int oflags, int devtype, struct thread *td);
+typedef int d_close_t(dev_t dev, int fflag, int devtype, struct thread *td);
+typedef void d_strategy_t(struct bio *bp);
+typedef int d_ioctl_t(dev_t dev, u_long cmd, caddr_t data,
+			   int fflag, struct thread *td);
+typedef int d_dump_t(dev_t dev);
+typedef int d_psize_t(dev_t dev);
+
+typedef int d_read_t(dev_t dev, struct uio *uio, int ioflag);
+typedef int d_write_t(dev_t dev, struct uio *uio, int ioflag);
+typedef int d_poll_t(dev_t dev, int events, struct thread *td);
+typedef int d_kqfilter_t(dev_t dev, struct knote *kn);
+typedef int d_mmap_t(dev_t dev, vm_offset_t offset, int nprot);
+
+typedef int l_open_t(dev_t dev, struct tty *tp);
+typedef int l_close_t(struct tty *tp, int flag);
+typedef int l_read_t(struct tty *tp, struct uio *uio, int flag);
+typedef int l_write_t(struct tty *tp, struct uio *uio, int flag);
+typedef int l_ioctl_t(struct tty *tp, u_long cmd, caddr_t data,
+			   int flag, struct thread *td);
+typedef int l_rint_t(int c, struct tty *tp);
+typedef int l_start_t(struct tty *tp);
+typedef int l_modem_t(struct tty *tp, int flag);
 
 /*
  * XXX: The dummy argument can be used to do what strategy1() never
@@ -249,8 +247,8 @@ struct linesw {
 extern struct linesw linesw[];
 extern int nlinesw;
 
-int ldisc_register __P((int , struct linesw *));
-void ldisc_deregister __P((int));
+int ldisc_register(int , struct linesw *);
+void ldisc_deregister(int);
 #define LDISC_LOAD 	-1		/* Loadable line discipline */
 #endif /* _KERNEL */
 
@@ -313,28 +311,28 @@ static moduledata_t name##_mod = {					\
 DECLARE_MODULE(name, name##_mod, SI_SUB_DRIVERS, SI_ORDER_MIDDLE)
 
 
-int	cdevsw_add __P((struct cdevsw *new));
-int	cdevsw_remove __P((struct cdevsw *old));
-int	count_dev __P((dev_t dev));
-void	destroy_dev __P((dev_t dev));
-void	revoke_and_destroy_dev __P((dev_t dev));
-struct cdevsw *devsw __P((dev_t dev));
-const char *devtoname __P((dev_t dev));
-int	dev_named __P((dev_t pdev, const char *name));
-void	dev_depends __P((dev_t pdev, dev_t cdev));
-void	freedev __P((dev_t dev));
-int	iszerodev __P((dev_t dev));
-dev_t	makebdev __P((int maj, int min));
-dev_t	make_dev __P((struct cdevsw *devsw, int minor, uid_t uid, gid_t gid, int perms, const char *fmt, ...)) __printflike(6, 7);
-dev_t	make_dev_alias __P((dev_t pdev, const char *fmt, ...)) __printflike(2, 3);
-int	dev2unit __P((dev_t dev));
-int	unit2minor __P((int unit));
-void	setconf __P((void));
+int	cdevsw_add(struct cdevsw *new);
+int	cdevsw_remove(struct cdevsw *old);
+int	count_dev(dev_t dev);
+void	destroy_dev(dev_t dev);
+void	revoke_and_destroy_dev(dev_t dev);
+struct cdevsw *devsw(dev_t dev);
+const char *devtoname(dev_t dev);
+int	dev_named(dev_t pdev, const char *name);
+void	dev_depends(dev_t pdev, dev_t cdev);
+void	freedev(dev_t dev);
+int	iszerodev(dev_t dev);
+dev_t	makebdev(int maj, int min);
+dev_t	make_dev(struct cdevsw *devsw, int minor, uid_t uid, gid_t gid, int perms, const char *fmt, ...) __printflike(6, 7);
+dev_t	make_dev_alias(dev_t pdev, const char *fmt, ...) __printflike(2, 3);
+int	dev2unit(dev_t dev);
+int	unit2minor(int unit);
+void	setconf(void);
 dev_t	getdiskbyname(char *name);
 
 /* This is type of the function DEVFS uses to hook into the kernel with */
-typedef void devfs_create_t __P((dev_t dev));
-typedef void devfs_destroy_t __P((dev_t dev));
+typedef void devfs_create_t(dev_t dev);
+typedef void devfs_destroy_t(dev_t dev);
 
 extern devfs_create_t *devfs_create_hook;
 extern devfs_destroy_t *devfs_destroy_hook;
@@ -351,9 +349,9 @@ extern int devfs_present;
 #define		GID_GAMES	13
 #define		GID_DIALER	68
 
-typedef void (*dev_clone_fn) __P((void *arg, char *name, int namelen, dev_t *result));
+typedef void (*dev_clone_fn)(void *arg, char *name, int namelen, dev_t *result);
 
-int dev_stdclone __P((char *name, char **namep, const char *stem, int *unit));
+int dev_stdclone(char *name, char **namep, const char *stem, int *unit);
 EVENTHANDLER_DECLARE(dev_clone, dev_clone_fn);
 #endif /* _KERNEL */
 
diff --git a/sys/sys/cons.h b/sys/sys/cons.h
index a65647e..6f64edc 100644
--- a/sys/sys/cons.h
+++ b/sys/sys/cons.h
@@ -43,13 +43,13 @@
 #define	_MACHINE_CONS_H_
 
 struct consdev;
-typedef	void	cn_probe_t __P((struct consdev *));
-typedef	void	cn_init_t __P((struct consdev *));
-typedef	void	cn_term_t __P((struct consdev *));
-typedef	int	cn_getc_t __P((dev_t));
-typedef	int	cn_checkc_t __P((dev_t));
-typedef	void	cn_putc_t __P((dev_t, int));
-typedef	void	cn_dbctl_t __P((dev_t, int));
+typedef	void	cn_probe_t(struct consdev *);
+typedef	void	cn_init_t(struct consdev *);
+typedef	void	cn_term_t(struct consdev *);
+typedef	int	cn_getc_t(dev_t);
+typedef	int	cn_checkc_t(dev_t);
+typedef	void	cn_putc_t(dev_t, int);
+typedef	void	cn_dbctl_t(dev_t, int);
 
 struct consdev {
 	cn_probe_t	*cn_probe;
diff --git a/sys/sys/disk.h b/sys/sys/disk.h
index 78ceb65..b224740 100644
--- a/sys/sys/disk.h
+++ b/sys/sys/disk.h
@@ -37,10 +37,10 @@ struct disk {
 #define DISKFLAG_LOCK		0x1
 #define DISKFLAG_WANTED		0x2
 
-dev_t disk_create __P((int unit, struct disk *disk, int flags, struct cdevsw *cdevsw, struct cdevsw *diskdevsw));
-void disk_destroy __P((dev_t dev));
-int disk_dumpcheck __P((dev_t dev, u_int *count, u_int *blkno, u_int *secsize));
-struct disk *disk_enumerate __P((struct disk *disk));
-void disk_invalidate __P((struct disk *disk));
+dev_t disk_create(int unit, struct disk *disk, int flags, struct cdevsw *cdevsw, struct cdevsw *diskdevsw);
+void disk_destroy(dev_t dev);
+int disk_dumpcheck(dev_t dev, u_int *count, u_int *blkno, u_int *secsize);
+struct disk *disk_enumerate(struct disk *disk);
+void disk_invalidate(struct disk *disk);
 
 #endif /* _SYS_DISK_H_ */
diff --git a/sys/sys/disklabel.h b/sys/sys/disklabel.h
index 4cf1223..046160a 100644
--- a/sys/sys/disklabel.h
+++ b/sys/sys/disklabel.h
@@ -186,7 +186,7 @@ struct disklabel {
 	} d_partitions[MAXPARTITIONS];	/* actually may be more */
 };
 
-static __inline u_int16_t dkcksum __P((struct disklabel *lp));
+static __inline u_int16_t dkcksum(struct disklabel *lp);
 static __inline u_int16_t
 dkcksum(lp)
 	struct disklabel *lp;
@@ -459,21 +459,21 @@ struct dos_partition {
 struct	bio;
 struct	bio_queue_head;
 
-int	bounds_check_with_label __P((struct bio *bp, struct disklabel *lp,
-				     int wlabel));
-void	diskerr __P((struct bio *bp, char *what, int blkdone,
-		     struct disklabel *lp));
-dev_t	dkmodpart __P((dev_t dev, int part));
-dev_t	dkmodslice __P((dev_t dev, int slice));
-u_int	dkunit __P((dev_t dev));
-char	*readdisklabel __P((dev_t dev, struct disklabel *lp));
-void	bioqdisksort __P((struct bio_queue_head *ap, struct bio *bp));
-int	setdisklabel __P((struct disklabel *olp, struct disklabel *nlp,
-			  u_long openmask));
-int	writedisklabel __P((dev_t dev, struct disklabel *lp));
+int	bounds_check_with_label(struct bio *bp, struct disklabel *lp,
+				     int wlabel);
+void	diskerr(struct bio *bp, char *what, int blkdone,
+		     struct disklabel *lp);
+dev_t	dkmodpart(dev_t dev, int part);
+dev_t	dkmodslice(dev_t dev, int slice);
+u_int	dkunit(dev_t dev);
+char	*readdisklabel(dev_t dev, struct disklabel *lp);
+void	bioqdisksort(struct bio_queue_head *ap, struct bio *bp);
+int	setdisklabel(struct disklabel *olp, struct disklabel *nlp,
+			  u_long openmask);
+int	writedisklabel(dev_t dev, struct disklabel *lp);
 #ifdef __alpha__
 struct	buf;			
-void	alpha_fix_srm_checksum __P((struct buf *bp));
+void	alpha_fix_srm_checksum(struct buf *bp);
 #endif
 
 #endif /* _KERNEL */
@@ -482,7 +482,7 @@ void	alpha_fix_srm_checksum __P((struct buf *bp));
 
 #ifndef _KERNEL
 __BEGIN_DECLS
-struct disklabel *getdiskbyname __P((const char *));
+struct disklabel *getdiskbyname(const char *);
 __END_DECLS
 #endif
 
diff --git a/sys/sys/diskmbr.h b/sys/sys/diskmbr.h
index 4cf1223..046160a 100644
--- a/sys/sys/diskmbr.h
+++ b/sys/sys/diskmbr.h
@@ -186,7 +186,7 @@ struct disklabel {
 	} d_partitions[MAXPARTITIONS];	/* actually may be more */
 };
 
-static __inline u_int16_t dkcksum __P((struct disklabel *lp));
+static __inline u_int16_t dkcksum(struct disklabel *lp);
 static __inline u_int16_t
 dkcksum(lp)
 	struct disklabel *lp;
@@ -459,21 +459,21 @@ struct dos_partition {
 struct	bio;
 struct	bio_queue_head;
 
-int	bounds_check_with_label __P((struct bio *bp, struct disklabel *lp,
-				     int wlabel));
-void	diskerr __P((struct bio *bp, char *what, int blkdone,
-		     struct disklabel *lp));
-dev_t	dkmodpart __P((dev_t dev, int part));
-dev_t	dkmodslice __P((dev_t dev, int slice));
-u_int	dkunit __P((dev_t dev));
-char	*readdisklabel __P((dev_t dev, struct disklabel *lp));
-void	bioqdisksort __P((struct bio_queue_head *ap, struct bio *bp));
-int	setdisklabel __P((struct disklabel *olp, struct disklabel *nlp,
-			  u_long openmask));
-int	writedisklabel __P((dev_t dev, struct disklabel *lp));
+int	bounds_check_with_label(struct bio *bp, struct disklabel *lp,
+				     int wlabel);
+void	diskerr(struct bio *bp, char *what, int blkdone,
+		     struct disklabel *lp);
+dev_t	dkmodpart(dev_t dev, int part);
+dev_t	dkmodslice(dev_t dev, int slice);
+u_int	dkunit(dev_t dev);
+char	*readdisklabel(dev_t dev, struct disklabel *lp);
+void	bioqdisksort(struct bio_queue_head *ap, struct bio *bp);
+int	setdisklabel(struct disklabel *olp, struct disklabel *nlp,
+			  u_long openmask);
+int	writedisklabel(dev_t dev, struct disklabel *lp);
 #ifdef __alpha__
 struct	buf;			
-void	alpha_fix_srm_checksum __P((struct buf *bp));
+void	alpha_fix_srm_checksum(struct buf *bp);
 #endif
 
 #endif /* _KERNEL */
@@ -482,7 +482,7 @@ void	alpha_fix_srm_checksum __P((struct buf *bp));
 
 #ifndef _KERNEL
 __BEGIN_DECLS
-struct disklabel *getdiskbyname __P((const char *));
+struct disklabel *getdiskbyname(const char *);
 __END_DECLS
 #endif
 
diff --git a/sys/sys/diskpc98.h b/sys/sys/diskpc98.h
index 4cf1223..046160a 100644
--- a/sys/sys/diskpc98.h
+++ b/sys/sys/diskpc98.h
@@ -186,7 +186,7 @@ struct disklabel {
 	} d_partitions[MAXPARTITIONS];	/* actually may be more */
 };
 
-static __inline u_int16_t dkcksum __P((struct disklabel *lp));
+static __inline u_int16_t dkcksum(struct disklabel *lp);
 static __inline u_int16_t
 dkcksum(lp)
 	struct disklabel *lp;
@@ -459,21 +459,21 @@ struct dos_partition {
 struct	bio;
 struct	bio_queue_head;
 
-int	bounds_check_with_label __P((struct bio *bp, struct disklabel *lp,
-				     int wlabel));
-void	diskerr __P((struct bio *bp, char *what, int blkdone,
-		     struct disklabel *lp));
-dev_t	dkmodpart __P((dev_t dev, int part));
-dev_t	dkmodslice __P((dev_t dev, int slice));
-u_int	dkunit __P((dev_t dev));
-char	*readdisklabel __P((dev_t dev, struct disklabel *lp));
-void	bioqdisksort __P((struct bio_queue_head *ap, struct bio *bp));
-int	setdisklabel __P((struct disklabel *olp, struct disklabel *nlp,
-			  u_long openmask));
-int	writedisklabel __P((dev_t dev, struct disklabel *lp));
+int	bounds_check_with_label(struct bio *bp, struct disklabel *lp,
+				     int wlabel);
+void	diskerr(struct bio *bp, char *what, int blkdone,
+		     struct disklabel *lp);
+dev_t	dkmodpart(dev_t dev, int part);
+dev_t	dkmodslice(dev_t dev, int slice);
+u_int	dkunit(dev_t dev);
+char	*readdisklabel(dev_t dev, struct disklabel *lp);
+void	bioqdisksort(struct bio_queue_head *ap, struct bio *bp);
+int	setdisklabel(struct disklabel *olp, struct disklabel *nlp,
+			  u_long openmask);
+int	writedisklabel(dev_t dev, struct disklabel *lp);
 #ifdef __alpha__
 struct	buf;			
-void	alpha_fix_srm_checksum __P((struct buf *bp));
+void	alpha_fix_srm_checksum(struct buf *bp);
 #endif
 
 #endif /* _KERNEL */
@@ -482,7 +482,7 @@ void	alpha_fix_srm_checksum __P((struct buf *bp));
 
 #ifndef _KERNEL
 __BEGIN_DECLS
-struct disklabel *getdiskbyname __P((const char *));
+struct disklabel *getdiskbyname(const char *);
 __END_DECLS
 #endif
 
diff --git a/sys/sys/diskslice.h b/sys/sys/diskslice.h
index 4c1054d..b633d2e 100644
--- a/sys/sys/diskslice.h
+++ b/sys/sys/diskslice.h
@@ -78,20 +78,20 @@ struct diskslices {
 struct bio;
 struct disklabel;
 
-int	dscheck __P((struct bio *bp, struct diskslices *ssp));
-void	dsclose __P((dev_t dev, int mode, struct diskslices *ssp));
-void	dsgone __P((struct diskslices **sspp));
-int	dsinit __P((dev_t dev, struct disklabel *lp,
-		     struct diskslices **sspp));
-int	dsioctl __P((dev_t dev, u_long cmd, caddr_t data,
-		     int flags, struct diskslices **sspp));
-int	dsisopen __P((struct diskslices *ssp));
-struct diskslices *dsmakeslicestruct __P((int nslices, struct disklabel *lp));
-char	*dsname __P((dev_t dev, int unit, int slice, int part,
-		     char *partname));
-int	dsopen __P((dev_t dev, int mode, u_int flags,
-		    struct diskslices **sspp, struct disklabel *lp));
-int	dssize __P((dev_t dev, struct diskslices **sspp));
+int	dscheck(struct bio *bp, struct diskslices *ssp);
+void	dsclose(dev_t dev, int mode, struct diskslices *ssp);
+void	dsgone(struct diskslices **sspp);
+int	dsinit(dev_t dev, struct disklabel *lp,
+		     struct diskslices **sspp);
+int	dsioctl(dev_t dev, u_long cmd, caddr_t data,
+		     int flags, struct diskslices **sspp);
+int	dsisopen(struct diskslices *ssp);
+struct diskslices *dsmakeslicestruct(int nslices, struct disklabel *lp);
+char	*dsname(dev_t dev, int unit, int slice, int part,
+		     char *partname);
+int	dsopen(dev_t dev, int mode, u_int flags,
+		    struct diskslices **sspp, struct disklabel *lp);
+int	dssize(dev_t dev, struct diskslices **sspp);
 
 #endif /* _KERNEL */
 
diff --git a/sys/sys/domain.h b/sys/sys/domain.h
index 2ae9fba..77b8ad8 100644
--- a/sys/sys/domain.h
+++ b/sys/sys/domain.h
@@ -50,15 +50,15 @@ struct domain {
 	int	dom_family;		/* AF_xxx */
 	char	*dom_name;
 	void	(*dom_init)		/* initialize domain data structures */
-		__P((void));
+		(void);
 	int	(*dom_externalize)	/* externalize access rights */
-		__P((struct mbuf *, struct mbuf **));
+		(struct mbuf *, struct mbuf **);
 	void	(*dom_dispose)		/* dispose of internalized rights */
-		__P((struct mbuf *));
+		(struct mbuf *);
 	struct	protosw *dom_protosw, *dom_protoswNPROTOSW;
 	struct	domain *dom_next;
 	int	(*dom_rtattach)		/* initialize routing table */
-		__P((void **, int));
+		(void **, int);
 	int	dom_rtoffset;		/* an arg to rtattach, in bits */
 	int	dom_maxrtkey;		/* for routing layer */
 };
diff --git a/sys/sys/errno.h b/sys/sys/errno.h
index 7f274d9..3558b36 100644
--- a/sys/sys/errno.h
+++ b/sys/sys/errno.h
@@ -45,7 +45,7 @@
 #ifndef _KERNEL
 #include <sys/cdefs.h>
 __BEGIN_DECLS
-int *	__error __P((void));
+int *	__error(void);
 __END_DECLS
 #define	errno		(* __error())
 #endif
diff --git a/sys/sys/event.h b/sys/sys/event.h
index 72035fb..e1ededb 100644
--- a/sys/sys/event.h
+++ b/sys/sys/event.h
@@ -136,9 +136,9 @@ MALLOC_DECLARE(M_KQUEUE);
 
 struct filterops {
 	int	f_isfd;		/* true if ident == filedescriptor */
-	int	(*f_attach)	__P((struct knote *kn));
-	void	(*f_detach)	__P((struct knote *kn));
-	int	(*f_event)	__P((struct knote *kn, long hint));
+	int	(*f_attach)	(struct knote *kn);
+	void	(*f_detach)	(struct knote *kn);
+	int	(*f_event)	(struct knote *kn, long hint);
 };
 
 struct knote {
@@ -186,10 +186,10 @@ extern int	kqueue_del_filteropts(int filt);
 struct timespec;
 
 __BEGIN_DECLS
-int     kqueue __P((void));
-int     kevent __P((int kq, const struct kevent *changelist, int nchanges,
+int     kqueue(void);
+int     kevent(int kq, const struct kevent *changelist, int nchanges,
 		    struct kevent *eventlist, int nevents,
-		    const struct timespec *timeout));
+		    const struct timespec *timeout);
 __END_DECLS
 
 #endif /* !_KERNEL */
diff --git a/sys/sys/eventhandler.h b/sys/sys/eventhandler.h
index 8d91641..7476b7d 100644
--- a/sys/sys/eventhandler.h
+++ b/sys/sys/eventhandler.h
@@ -165,7 +165,7 @@ extern struct eventhandler_list	*eventhandler_find_list(char *name);
  */
 
 /* Shutdown events */
-typedef void (*shutdown_fn) __P((void *, int));
+typedef void (*shutdown_fn)(void *, int);
 
 #define	SHUTDOWN_PRI_FIRST	0
 #define	SHUTDOWN_PRI_DEFAULT	10000
@@ -176,7 +176,7 @@ EVENTHANDLER_DECLARE(shutdown_post_sync, shutdown_fn);	/* after fs sync */
 EVENTHANDLER_DECLARE(shutdown_final, shutdown_fn);
 
 /* Idle process event */
-typedef void (*idle_eventhandler_t) __P((void *, int));
+typedef void (*idle_eventhandler_t)(void *, int);
 
 #define IDLE_PRI_FIRST		10000
 #define IDLE_PRI_LAST		20000
diff --git a/sys/sys/exec.h b/sys/sys/exec.h
index 58e1c65..66d2f7b 100644
--- a/sys/sys/exec.h
+++ b/sys/sys/exec.h
@@ -66,7 +66,7 @@ struct ps_strings {
 struct image_params;
 
 struct execsw {
-	int (*ex_imgact) __P((struct image_params *));
+	int (*ex_imgact)(struct image_params *);
 	const char *ex_name;
 };
 
@@ -75,11 +75,11 @@ struct execsw {
 #ifdef _KERNEL
 #include <sys/cdefs.h>
 
-int exec_map_first_page __P((struct image_params *));        
-void exec_unmap_first_page __P((struct image_params *));       
+int exec_map_first_page(struct image_params *);        
+void exec_unmap_first_page(struct image_params *);       
 
-int exec_register __P((const struct execsw *));
-int exec_unregister __P((const struct execsw *));
+int exec_register(const struct execsw *);
+int exec_unregister(const struct execsw *);
 
 /*
  * note: name##_mod cannot be const storage because the
diff --git a/sys/sys/fcntl.h b/sys/sys/fcntl.h
index bec6e5d..30f9a09 100644
--- a/sys/sys/fcntl.h
+++ b/sys/sys/fcntl.h
@@ -200,11 +200,11 @@ struct flock {
 #include <sys/cdefs.h>
 
 __BEGIN_DECLS
-int	open __P((const char *, int, ...));
-int	creat __P((const char *, mode_t));
-int	fcntl __P((int, int, ...));
+int	open(const char *, int, ...);
+int	creat(const char *, mode_t);
+int	fcntl(int, int, ...);
 #ifndef _POSIX_SOURCE
-int	flock __P((int, int));
+int	flock(int, int);
 #endif /* !_POSIX_SOURCE */
 __END_DECLS
 #endif
diff --git a/sys/sys/file.h b/sys/sys/file.h
index f64fd40..50b560b 100644
--- a/sys/sys/file.h
+++ b/sys/sys/file.h
@@ -79,22 +79,22 @@ struct file {
 	int	f_msgcount;	/* (f) references from message queue */
 	struct	ucred *f_cred;	/* credentials associated with descriptor */
 	struct fileops {
-		int	(*fo_read)	__P((struct file *fp, struct uio *uio,
+		int	(*fo_read)	(struct file *fp, struct uio *uio,
 					    struct ucred *cred, int flags,
-					    struct thread *td));
-		int	(*fo_write)	__P((struct file *fp, struct uio *uio,
+					    struct thread *td);
+		int	(*fo_write)	(struct file *fp, struct uio *uio,
 					    struct ucred *cred, int flags,
-					    struct thread *td));
+					    struct thread *td);
 #define	FOF_OFFSET	1
-		int	(*fo_ioctl)	__P((struct file *fp, u_long com,
-					    caddr_t data, struct thread *td));
-		int	(*fo_poll)	__P((struct file *fp, int events,
-					    struct ucred *cred, struct thread *td));
-		int	(*fo_kqfilter)	__P((struct file *fp,
-					    struct knote *kn));
-		int	(*fo_stat)	__P((struct file *fp, struct stat *sb,
-					    struct thread *td));
-		int	(*fo_close)	__P((struct file *fp, struct thread *td));
+		int	(*fo_ioctl)	(struct file *fp, u_long com,
+					    caddr_t data, struct thread *td);
+		int	(*fo_poll)	(struct file *fp, int events,
+					    struct ucred *cred,
+					    struct thread *td);
+		int	(*fo_kqfilter)	(struct file *fp, struct knote *kn);
+		int	(*fo_stat)	(struct file *fp, struct stat *sb,
+					    struct thread *td);
+		int	(*fo_close)	(struct file *fp, struct thread *td);
 	} *f_ops;
 	int	f_seqcount;	/*
 				 * count of sequential accesses -- cleared
@@ -122,11 +122,11 @@ extern int maxfilesperproc;	/* per process limit on number of open files */
 extern int nfiles;		/* (fl) actual number of open files */
 extern struct sx filelist_lock; /* sx to protect filelist and nfiles */
 
-int fget __P((struct thread *td, int fd, struct file **fpp));
-int fget_read __P((struct thread *td, int fd, struct file **fpp));
-int fget_write __P((struct thread *td, int fd, struct file **fpp));
-int fdrop __P((struct file *fp, struct thread *td));
-int fdrop_locked __P((struct file *fp, struct thread *td));
+int fget(struct thread *td, int fd, struct file **fpp);
+int fget_read(struct thread *td, int fd, struct file **fpp);
+int fget_write(struct thread *td, int fd, struct file **fpp);
+int fdrop(struct file *fp, struct thread *td);
+int fdrop_locked(struct file *fp, struct thread *td);
 
 /* Lock a file. */
 #define	FILE_LOCK(f)	mtx_lock((f)->f_mtxp)
@@ -134,12 +134,12 @@ int fdrop_locked __P((struct file *fp, struct thread *td));
 #define	FILE_LOCKED(f)	mtx_owned((f)->f_mtxp)
 #define	FILE_LOCK_ASSERT(f, type) mtx_assert((f)->f_mtxp, (type))
 
-int fgetvp __P((struct thread *td, int fd, struct vnode **vpp));
-int fgetvp_read __P((struct thread *td, int fd, struct vnode **vpp));
-int fgetvp_write __P((struct thread *td, int fd, struct vnode **vpp));
+int fgetvp(struct thread *td, int fd, struct vnode **vpp);
+int fgetvp_read(struct thread *td, int fd, struct vnode **vpp);
+int fgetvp_write(struct thread *td, int fd, struct vnode **vpp);
 
-int fgetsock __P((struct thread *td, int fd, struct socket **spp, u_int *fflagp));
-void fputsock __P((struct socket *sp));
+int fgetsock(struct thread *td, int fd, struct socket **spp, u_int *fflagp);
+void fputsock(struct socket *sp);
 
 #define	fhold_locked(fp)						\
 	do {								\
@@ -154,18 +154,18 @@ void fputsock __P((struct socket *sp));
 		FILE_UNLOCK(fp);					\
 	} while (0)
 
-static __inline int fo_read __P((struct file *fp, struct uio *uio,
-    struct ucred *cred, int flags, struct thread *td));
-static __inline int fo_write __P((struct file *fp, struct uio *uio,
-    struct ucred *cred, int flags, struct thread *td));
-static __inline int fo_ioctl __P((struct file *fp, u_long com, caddr_t data,
-    struct thread *td));
-static __inline int fo_poll __P((struct file *fp, int events,
-    struct ucred *cred, struct thread *td));
-static __inline int fo_stat __P((struct file *fp, struct stat *sb,
-    struct thread *td));
-static __inline int fo_close __P((struct file *fp, struct thread *td));
-static __inline int fo_kqfilter __P((struct file *fp, struct knote *kn));
+static __inline int fo_read(struct file *fp, struct uio *uio,
+    struct ucred *cred, int flags, struct thread *td);
+static __inline int fo_write(struct file *fp, struct uio *uio,
+    struct ucred *cred, int flags, struct thread *td);
+static __inline int fo_ioctl(struct file *fp, u_long com, caddr_t data,
+    struct thread *td);
+static __inline int fo_poll(struct file *fp, int events,
+    struct ucred *cred, struct thread *td);
+static __inline int fo_stat(struct file *fp, struct stat *sb,
+    struct thread *td);
+static __inline int fo_close(struct file *fp, struct thread *td);
+static __inline int fo_kqfilter(struct file *fp, struct knote *kn);
 struct proc;
 
 static __inline int
diff --git a/sys/sys/filedesc.h b/sys/sys/filedesc.h
index ef833fbf..05bb4e0 100644
--- a/sys/sys/filedesc.h
+++ b/sys/sys/filedesc.h
@@ -138,25 +138,25 @@ SLIST_HEAD(sigiolst, sigio);
 #define	FILEDESC_LOCKED(fd)	mtx_owned(&(fd)->fd_mtx)
 #define	FILEDESC_LOCK_ASSERT(fd, type)	mtx_assert(&(fd)->fd_mtx, (type))
 
-int	closef __P((struct file *fp, struct thread *p));
-int	dupfdopen __P((struct thread *td, struct filedesc *fdp, int indx, int dfd, int mode,
-		       int error));
-int	falloc __P((struct thread *p, struct file **resultfp, int *resultfd));
-int	fdalloc __P((struct thread *p, int want, int *result));
-int	fdavail __P((struct thread *td, int n));
-void	fdcloseexec __P((struct thread *td));
-struct	filedesc *fdcopy __P((struct thread *td));
-void	fdfree __P((struct thread *td));
-struct	filedesc *fdinit __P((struct thread *td));
-struct	filedesc *fdshare __P((struct proc *p));
-void	ffree __P((struct file *fp));
-static __inline struct file *	fget_locked __P((struct filedesc *fdp, int fd));
-pid_t	fgetown __P((struct sigio *sigio));
-int	fsetown __P((pid_t pgid, struct sigio **sigiop));
-void	funsetown __P((struct sigio *sigio));
-void	funsetownlst __P((struct sigiolst *sigiolst));
-int	getvnode __P((struct filedesc *fdp, int fd, struct file **fpp));
-void	setugidsafety __P((struct thread *td));
+int	closef(struct file *fp, struct thread *p);
+int	dupfdopen(struct thread *td, struct filedesc *fdp, int indx,
+		       int dfd, int mode, int error);
+int	falloc(struct thread *p, struct file **resultfp, int *resultfd);
+int	fdalloc(struct thread *p, int want, int *result);
+int	fdavail(struct thread *td, int n);
+void	fdcloseexec(struct thread *td);
+struct	filedesc *fdcopy(struct thread *td);
+void	fdfree(struct thread *td);
+struct	filedesc *fdinit(struct thread *td);
+struct	filedesc *fdshare(struct proc *p);
+void	ffree(struct file *fp);
+static __inline struct file *	fget_locked(struct filedesc *fdp, int fd);
+pid_t	fgetown(struct sigio *sigio);
+int	fsetown(pid_t pgid, struct sigio **sigiop);
+void	funsetown(struct sigio *sigio);
+void	funsetownlst(struct sigiolst *sigiolst);
+int	getvnode(struct filedesc *fdp, int fd, struct file **fpp);
+void	setugidsafety(struct thread *td);
 
 static __inline struct file *
 fget_locked(fdp, fd)
diff --git a/sys/sys/imgact.h b/sys/sys/imgact.h
index b6f67a4..9162484 100644
--- a/sys/sys/imgact.h
+++ b/sys/sys/imgact.h
@@ -62,10 +62,10 @@ struct image_params {
 };
 
 #ifdef _KERNEL
-int	exec_check_permissions __P((struct image_params *));
-int	exec_extract_strings __P((struct image_params *));
-int	exec_new_vmspace __P((struct image_params *));
-int	exec_shell_imgact __P((struct image_params *));
+int	exec_check_permissions(struct image_params *);
+int	exec_extract_strings(struct image_params *);
+int	exec_new_vmspace(struct image_params *);
+int	exec_shell_imgact(struct image_params *);
 #endif
 
 #endif /* !_SYS_IMGACT_H_ */
diff --git a/sys/sys/imgact_aout.h b/sys/sys/imgact_aout.h
index 07d03d0..7bff2a3 100644
--- a/sys/sys/imgact_aout.h
+++ b/sys/sys/imgact_aout.h
@@ -150,7 +150,7 @@ struct exec {
 #ifdef _KERNEL
 struct thread;
 
-int	aout_coredump __P((struct thread *td, struct vnode *vp, off_t limit));
+int	aout_coredump(struct thread *td, struct vnode *vp, off_t limit);
 #endif
 
 #endif /* !_IMGACT_AOUT_H_ */
diff --git a/sys/sys/imgact_elf.h b/sys/sys/imgact_elf.h
index b50f6e8..9615e62 100644
--- a/sys/sys/imgact_elf.h
+++ b/sys/sys/imgact_elf.h
@@ -65,9 +65,9 @@ typedef struct {
 
 #define MAX_BRANDS      8
 
-int	elf_brand_inuse        __P((Elf32_Brandinfo *entry));
-int	elf_insert_brand_entry __P((Elf32_Brandinfo *entry));
-int	elf_remove_brand_entry __P((Elf32_Brandinfo *entry));
+int	elf_brand_inuse(Elf32_Brandinfo *entry);
+int	elf_insert_brand_entry(Elf32_Brandinfo *entry);
+int	elf_remove_brand_entry(Elf32_Brandinfo *entry);
 
 #else /* !(ELF_TARG_CLASS == ELFCLASS32) */
 
@@ -97,15 +97,15 @@ typedef struct {
 
 #define MAX_BRANDS      8
 
-int	elf_brand_inuse        __P((Elf64_Brandinfo *entry));
-int	elf_insert_brand_entry __P((Elf64_Brandinfo *entry));
-int	elf_remove_brand_entry __P((Elf64_Brandinfo *entry));
+int	elf_brand_inuse(Elf64_Brandinfo *entry);
+int	elf_insert_brand_entry(Elf64_Brandinfo *entry);
+int	elf_remove_brand_entry(Elf64_Brandinfo *entry);
 
 #endif /* ELF_TARG_CLASS == ELFCLASS32 */
 
 struct thread;
 
-int	elf_coredump __P((struct thread *, struct vnode *, off_t));
+int	elf_coredump(struct thread *, struct vnode *, off_t);
 
 #endif /* _KERNEL */
 
diff --git a/sys/sys/inflate.h b/sys/sys/inflate.h
index 05ccf17..528b536 100644
--- a/sys/sys/inflate.h
+++ b/sys/sys/inflate.h
@@ -29,10 +29,10 @@ struct inflate {
 	void           *gz_private;
 
 	/* Fetch next character to be uncompressed */
-	int             (*gz_input) __P((void *));
+	int             (*gz_input)(void *);
 
 	/* Dispose of uncompressed characters */
-	int             (*gz_output) __P((void *, u_char *, u_long));
+	int             (*gz_output)(void *, u_char *, u_long);
 
 	/* Private part */
 	u_long          gz_bb;	/* bit buffer */
@@ -46,7 +46,7 @@ struct inflate {
 	unsigned        gz_wp;
 };
 
-int inflate     __P((struct inflate *));
+int inflate(struct inflate *);
 
 #endif	/* _KERNEL || KZIP */
 
diff --git a/sys/sys/interrupt.h b/sys/sys/interrupt.h
index 4e1a934..61d3ab6 100644
--- a/sys/sys/interrupt.h
+++ b/sys/sys/interrupt.h
@@ -109,19 +109,19 @@ extern char 	eintrnames[];	/* end of intrnames[] */
 extern u_long 	intrcnt[];	/* counts for for each device and stray */
 extern char 	intrnames[];	/* string table containing device names */
 
-int	ithread_create __P((struct ithd **ithread, int vector, int flags,
-	    void (*disable)(int), void (*enable)(int), const char *fmt, ...))
+int	ithread_create(struct ithd **ithread, int vector, int flags,
+	    void (*disable)(int), void (*enable)(int), const char *fmt, ...)
 	    __printflike(6, 7);
-int	ithread_destroy __P((struct ithd *ithread));
-u_char	ithread_priority __P((enum intr_type flags));
-int	ithread_add_handler __P((struct ithd *ithread, const char *name,
+int	ithread_destroy(struct ithd *ithread);
+u_char	ithread_priority(enum intr_type flags);
+int	ithread_add_handler(struct ithd *ithread, const char *name,
 	    driver_intr_t handler, void *arg, u_char pri, enum intr_type flags,
-	    void **cookiep));
-int	ithread_remove_handler __P((void *cookie));
-int	ithread_schedule __P((struct ithd *ithread, int do_switch));
-int     swi_add __P((struct ithd **ithdp, const char *name,
+	    void **cookiep);
+int	ithread_remove_handler(void *cookie);
+int	ithread_schedule(struct ithd *ithread, int do_switch);
+int     swi_add(struct ithd **ithdp, const char *name,
 	    driver_intr_t handler, void *arg, int pri, enum intr_type flags,
-	    void **cookiep));
-void	swi_sched __P((void *cookie, int flags));
+	    void **cookiep);
+void	swi_sched(void *cookie, int flags);
 
 #endif
diff --git a/sys/sys/ioccom.h b/sys/sys/ioccom.h
index 7e6fbde..c6e00df 100644
--- a/sys/sys/ioccom.h
+++ b/sys/sys/ioccom.h
@@ -67,7 +67,7 @@
 #include <sys/cdefs.h>
 
 __BEGIN_DECLS
-int	ioctl __P((int, unsigned long, ...));
+int	ioctl(int, unsigned long, ...);
 __END_DECLS
 
 #endif
diff --git a/sys/sys/ipc.h b/sys/sys/ipc.h
index 9d748de..96b3951 100644
--- a/sys/sys/ipc.h
+++ b/sys/sys/ipc.h
@@ -86,7 +86,7 @@ struct ipc_perm {
 struct thread;
 struct proc;
 
-int	ipcperm __P((struct thread *, struct ipc_perm *, int));
+int	ipcperm(struct thread *, struct ipc_perm *, int);
 extern void (*shmfork_hook)(struct proc *, struct proc *);
 extern void (*shmexit_hook)(struct proc *);
 
@@ -97,7 +97,7 @@ extern void (*shmexit_hook)(struct proc *);
 #include <sys/cdefs.h>
 
 __BEGIN_DECLS
-key_t	ftok __P((const char *, int));
+key_t	ftok(const char *, int);
 __END_DECLS
 
 #endif /* _KERNEL */
diff --git a/sys/sys/jail.h b/sys/sys/jail.h
index 1fef842..f0fb9f6 100644
--- a/sys/sys/jail.h
+++ b/sys/sys/jail.h
@@ -22,7 +22,7 @@ struct jail {
 
 #ifndef _KERNEL
 
-int jail __P((struct jail *));
+int jail(struct jail *);
 
 #else /* _KERNEL */
 
@@ -67,15 +67,15 @@ extern int	jail_sysvipc_allowed;
  */
 struct ucred;
 struct sockaddr;
-int jailed __P((struct ucred *cred));
-void getcredhostname __P((struct ucred *cred, char *, size_t));
-int prison_check __P((struct ucred *cred1, struct ucred *cred2));
-void prison_free __P((struct prison *pr));
-u_int32_t prison_getip __P((struct ucred *cred));
-void prison_hold __P((struct prison *pr));
-int prison_if __P((struct ucred *cred, struct sockaddr *sa));
-int prison_ip __P((struct ucred *cred, int flag, u_int32_t *ip));
-void prison_remote_ip __P((struct ucred *cred, int flags, u_int32_t *ip));
+int jailed(struct ucred *cred);
+void getcredhostname(struct ucred *cred, char *, size_t);
+int prison_check(struct ucred *cred1, struct ucred *cred2);
+void prison_free(struct prison *pr);
+u_int32_t prison_getip(struct ucred *cred);
+void prison_hold(struct prison *pr);
+int prison_if(struct ucred *cred, struct sockaddr *sa);
+int prison_ip(struct ucred *cred, int flag, u_int32_t *ip);
+void prison_remote_ip(struct ucred *cred, int flags, u_int32_t *ip);
 
 #endif /* !_KERNEL */
 #endif /* !_SYS_JAIL_H_ */
diff --git a/sys/sys/kernel.h b/sys/sys/kernel.h
index 6787430..7bc3a3e 100644
--- a/sys/sys/kernel.h
+++ b/sys/sys/kernel.h
@@ -204,8 +204,8 @@ enum sysinit_elem_order {
  * modifiable or not.
  */
 
-typedef void (*sysinit_nfunc_t) __P((void *));
-typedef void (*sysinit_cfunc_t) __P((const void *));
+typedef void (*sysinit_nfunc_t)(void *);
+typedef void (*sysinit_cfunc_t)(const void *);
 
 struct sysinit {
 	enum sysinit_sub_id	subsystem;	/* subsystem identifier*/
@@ -255,7 +255,7 @@ struct sysinit {
 	C_SYSUNINIT(uniquifier, subsystem, order,		\
 	(sysinit_cfunc_t)(sysinit_nfunc_t)func, (void *)ident)
 
-void	sysinit_add __P((struct sysinit **set, struct sysinit **set_end));
+void	sysinit_add(struct sysinit **set, struct sysinit **set_end);
 
 /*
  * Infrastructure for tunable 'constants'.  Value may be specified at compile
@@ -328,11 +328,11 @@ struct tunable_str {
 
 struct intr_config_hook {
 	TAILQ_ENTRY(intr_config_hook) ich_links;
-	void	(*ich_func) __P((void *arg));
+	void	(*ich_func)(void *arg);
 	void	*ich_arg;
 };
 
-int	config_intrhook_establish __P((struct intr_config_hook *hook));
-void	config_intrhook_disestablish __P((struct intr_config_hook *hook));
+int	config_intrhook_establish(struct intr_config_hook *hook);
+void	config_intrhook_disestablish(struct intr_config_hook *hook);
 
 #endif /* !_SYS_KERNEL_H_*/
diff --git a/sys/sys/kthread.h b/sys/sys/kthread.h
index 279f597..548c410 100644
--- a/sys/sys/kthread.h
+++ b/sys/sys/kthread.h
@@ -38,17 +38,17 @@
  */
 struct kproc_desc {
 	char		*arg0;			/* arg 0 (for 'ps' listing) */
-	void		(*func) __P((void));	/* "main" for kernel process */
+	void		(*func)(void);	/* "main" for kernel process */
 	struct proc	**global_procpp;	/* ptr to proc ptr save area */
 };
 
-void	kproc_shutdown __P((void *, int));
-void	kproc_start __P((const void *));
-int     kthread_create __P((void (*)(void *), void *, struct proc **,
-	    int flags, const char *, ...)) __printflike(5, 6);
-void    kthread_exit __P((int)) __dead2;
-int	kthread_resume __P((struct proc *)); /* XXXKSE */
-int	kthread_suspend __P((struct proc *, int)); /* XXXKSE */
-void	kthread_suspend_check __P((struct proc *)); /* XXXKSE */
+void	kproc_shutdown(void *, int);
+void	kproc_start(const void *);
+int     kthread_create(void (*)(void *), void *, struct proc **,
+	    int flags, const char *, ...) __printflike(5, 6);
+void    kthread_exit(int) __dead2;
+int	kthread_resume(struct proc *); /* XXXKSE */
+int	kthread_suspend(struct proc *, int); /* XXXKSE */
+void	kthread_suspend_check(struct proc *); /* XXXKSE */
 
 #endif /* !_SYS_KTHREAD_H_ */
diff --git a/sys/sys/ktrace.h b/sys/sys/ktrace.h
index 2ca616b..e72a4cb 100644
--- a/sys/sys/ktrace.h
+++ b/sys/sys/ktrace.h
@@ -158,20 +158,20 @@ struct ktr_csw {
 #define KTRFAC_ACTIVE	0x20000000	/* ktrace logging in progress, ignore */
 
 #ifdef	_KERNEL
-void	ktrnamei __P((struct vnode *,char *));
-void	ktrcsw __P((struct vnode *,int,int));
-void	ktrpsig __P((struct vnode *, int, sig_t, sigset_t *, int));
-void	ktrgenio __P((struct vnode *, int, enum uio_rw, struct uio *, int));
-void	ktrsyscall __P((struct vnode *, int, int narg, register_t args[]));
-void	ktrsysret __P((struct vnode *, int, int, register_t));
+void	ktrnamei(struct vnode *,char *);
+void	ktrcsw(struct vnode *,int,int);
+void	ktrpsig(struct vnode *, int, sig_t, sigset_t *, int);
+void	ktrgenio(struct vnode *, int, enum uio_rw, struct uio *, int);
+void	ktrsyscall(struct vnode *, int, int narg, register_t args[]);
+void	ktrsysret(struct vnode *, int, int, register_t);
 
 #else
 
 #include <sys/cdefs.h>
 
 __BEGIN_DECLS
-int	ktrace __P((const char *, int, int, pid_t));
-int	utrace __P((const void *, size_t));
+int	ktrace(const char *, int, int, pid_t);
+int	utrace(const void *, size_t);
 __END_DECLS
 
 #endif
diff --git a/sys/sys/libkern.h b/sys/sys/libkern.h
index 5049d3e..691ace7 100644
--- a/sys/sys/libkern.h
+++ b/sys/sys/libkern.h
@@ -64,32 +64,32 @@ static __inline u_long ulmax(u_long a, u_long b) { return (a > b ? a : b); }
 static __inline u_long ulmin(u_long a, u_long b) { return (a < b ? a : b); }
 
 /* Prototypes for non-quad routines. */
-u_int32_t arc4random __P((void));
-int	 bcmp __P((const void *, const void *, size_t));
-void	*bsearch __P((const void *, const void *, size_t,
-	    size_t, int (*)(const void *, const void *)));
+u_int32_t arc4random(void);
+int	 bcmp(const void *, const void *, size_t);
+void	*bsearch(const void *, const void *, size_t,
+	    size_t, int (*)(const void *, const void *));
 #ifndef HAVE_INLINE_FFS
-int	 ffs __P((int));
+int	 ffs(int);
 #endif
 #ifndef	HAVE_INLINE_FLS
-int	 fls __P((int));
+int	 fls(int);
 #endif
-int	 locc __P((int, char *, u_int));
-void	 qsort __P((void *base, size_t nmemb, size_t size,
-		    int (*compar)(const void *, const void *)));
-u_long	 random __P((void));
-char	*index __P((const char *, int));
-char	*rindex __P((const char *, int));
-int	 scanc __P((u_int, const u_char *, const u_char *, int));
-int	 skpc __P((int, int, char *));
-void	 srandom __P((u_long));
-char	*strcat __P((char *, const char *));
-int	 strcmp __P((const char *, const char *));
-char	*strcpy __P((char *, const char *));
-size_t	 strlen __P((const char *));
-int	 strncmp __P((const char *, const char *, size_t));
-char	*strncpy __P((char *, const char *, size_t));
-int	 strvalid __P((const char *, size_t));
+int	 locc(int, char *, u_int);
+void	 qsort(void *base, size_t nmemb, size_t size,
+		    int (*compar)(const void *, const void *));
+u_long	 random(void);
+char	*index(const char *, int);
+char	*rindex(const char *, int);
+int	 scanc(u_int, const u_char *, const u_char *, int);
+int	 skpc(int, int, char *);
+void	 srandom(u_long);
+char	*strcat(char *, const char *);
+int	 strcmp(const char *, const char *);
+char	*strcpy(char *, const char *);
+size_t	 strlen(const char *);
+int	 strncmp(const char *, const char *, size_t);
+char	*strncpy(char *, const char *, size_t);
+int	 strvalid(const char *, size_t);
 
 
 static __inline int
diff --git a/sys/sys/linedisc.h b/sys/sys/linedisc.h
index f4e3dde..ed93cdf 100644
--- a/sys/sys/linedisc.h
+++ b/sys/sys/linedisc.h
@@ -134,31 +134,29 @@ struct knote;
 
 typedef struct thread d_thread_t;
 
-typedef int d_open_t __P((dev_t dev, int oflags, int devtype,
-			  struct thread *td));
-typedef int d_close_t __P((dev_t dev, int fflag, int devtype,
-			   struct thread *td));
-typedef void d_strategy_t __P((struct bio *bp));
-typedef int d_ioctl_t __P((dev_t dev, u_long cmd, caddr_t data,
-			   int fflag, struct thread *td));
-typedef int d_dump_t __P((dev_t dev));
-typedef int d_psize_t __P((dev_t dev));
-
-typedef int d_read_t __P((dev_t dev, struct uio *uio, int ioflag));
-typedef int d_write_t __P((dev_t dev, struct uio *uio, int ioflag));
-typedef int d_poll_t __P((dev_t dev, int events, struct thread *td));
-typedef int d_kqfilter_t __P((dev_t dev, struct knote *kn));
-typedef int d_mmap_t __P((dev_t dev, vm_offset_t offset, int nprot));
-
-typedef int l_open_t __P((dev_t dev, struct tty *tp));
-typedef int l_close_t __P((struct tty *tp, int flag));
-typedef int l_read_t __P((struct tty *tp, struct uio *uio, int flag));
-typedef int l_write_t __P((struct tty *tp, struct uio *uio, int flag));
-typedef int l_ioctl_t __P((struct tty *tp, u_long cmd, caddr_t data,
-			   int flag, struct thread*td));
-typedef int l_rint_t __P((int c, struct tty *tp));
-typedef int l_start_t __P((struct tty *tp));
-typedef int l_modem_t __P((struct tty *tp, int flag));
+typedef int d_open_t(dev_t dev, int oflags, int devtype, struct thread *td);
+typedef int d_close_t(dev_t dev, int fflag, int devtype, struct thread *td);
+typedef void d_strategy_t(struct bio *bp);
+typedef int d_ioctl_t(dev_t dev, u_long cmd, caddr_t data,
+			   int fflag, struct thread *td);
+typedef int d_dump_t(dev_t dev);
+typedef int d_psize_t(dev_t dev);
+
+typedef int d_read_t(dev_t dev, struct uio *uio, int ioflag);
+typedef int d_write_t(dev_t dev, struct uio *uio, int ioflag);
+typedef int d_poll_t(dev_t dev, int events, struct thread *td);
+typedef int d_kqfilter_t(dev_t dev, struct knote *kn);
+typedef int d_mmap_t(dev_t dev, vm_offset_t offset, int nprot);
+
+typedef int l_open_t(dev_t dev, struct tty *tp);
+typedef int l_close_t(struct tty *tp, int flag);
+typedef int l_read_t(struct tty *tp, struct uio *uio, int flag);
+typedef int l_write_t(struct tty *tp, struct uio *uio, int flag);
+typedef int l_ioctl_t(struct tty *tp, u_long cmd, caddr_t data,
+			   int flag, struct thread *td);
+typedef int l_rint_t(int c, struct tty *tp);
+typedef int l_start_t(struct tty *tp);
+typedef int l_modem_t(struct tty *tp, int flag);
 
 /*
  * XXX: The dummy argument can be used to do what strategy1() never
@@ -249,8 +247,8 @@ struct linesw {
 extern struct linesw linesw[];
 extern int nlinesw;
 
-int ldisc_register __P((int , struct linesw *));
-void ldisc_deregister __P((int));
+int ldisc_register(int , struct linesw *);
+void ldisc_deregister(int);
 #define LDISC_LOAD 	-1		/* Loadable line discipline */
 #endif /* _KERNEL */
 
@@ -313,28 +311,28 @@ static moduledata_t name##_mod = {					\
 DECLARE_MODULE(name, name##_mod, SI_SUB_DRIVERS, SI_ORDER_MIDDLE)
 
 
-int	cdevsw_add __P((struct cdevsw *new));
-int	cdevsw_remove __P((struct cdevsw *old));
-int	count_dev __P((dev_t dev));
-void	destroy_dev __P((dev_t dev));
-void	revoke_and_destroy_dev __P((dev_t dev));
-struct cdevsw *devsw __P((dev_t dev));
-const char *devtoname __P((dev_t dev));
-int	dev_named __P((dev_t pdev, const char *name));
-void	dev_depends __P((dev_t pdev, dev_t cdev));
-void	freedev __P((dev_t dev));
-int	iszerodev __P((dev_t dev));
-dev_t	makebdev __P((int maj, int min));
-dev_t	make_dev __P((struct cdevsw *devsw, int minor, uid_t uid, gid_t gid, int perms, const char *fmt, ...)) __printflike(6, 7);
-dev_t	make_dev_alias __P((dev_t pdev, const char *fmt, ...)) __printflike(2, 3);
-int	dev2unit __P((dev_t dev));
-int	unit2minor __P((int unit));
-void	setconf __P((void));
+int	cdevsw_add(struct cdevsw *new);
+int	cdevsw_remove(struct cdevsw *old);
+int	count_dev(dev_t dev);
+void	destroy_dev(dev_t dev);
+void	revoke_and_destroy_dev(dev_t dev);
+struct cdevsw *devsw(dev_t dev);
+const char *devtoname(dev_t dev);
+int	dev_named(dev_t pdev, const char *name);
+void	dev_depends(dev_t pdev, dev_t cdev);
+void	freedev(dev_t dev);
+int	iszerodev(dev_t dev);
+dev_t	makebdev(int maj, int min);
+dev_t	make_dev(struct cdevsw *devsw, int minor, uid_t uid, gid_t gid, int perms, const char *fmt, ...) __printflike(6, 7);
+dev_t	make_dev_alias(dev_t pdev, const char *fmt, ...) __printflike(2, 3);
+int	dev2unit(dev_t dev);
+int	unit2minor(int unit);
+void	setconf(void);
 dev_t	getdiskbyname(char *name);
 
 /* This is type of the function DEVFS uses to hook into the kernel with */
-typedef void devfs_create_t __P((dev_t dev));
-typedef void devfs_destroy_t __P((dev_t dev));
+typedef void devfs_create_t(dev_t dev);
+typedef void devfs_destroy_t(dev_t dev);
 
 extern devfs_create_t *devfs_create_hook;
 extern devfs_destroy_t *devfs_destroy_hook;
@@ -351,9 +349,9 @@ extern int devfs_present;
 #define		GID_GAMES	13
 #define		GID_DIALER	68
 
-typedef void (*dev_clone_fn) __P((void *arg, char *name, int namelen, dev_t *result));
+typedef void (*dev_clone_fn)(void *arg, char *name, int namelen, dev_t *result);
 
-int dev_stdclone __P((char *name, char **namep, const char *stem, int *unit));
+int dev_stdclone(char *name, char **namep, const char *stem, int *unit);
 EVENTHANDLER_DECLARE(dev_clone, dev_clone_fn);
 #endif /* _KERNEL */
 
diff --git a/sys/sys/lockf.h b/sys/sys/lockf.h
index 836c7a9..bc51879 100644
--- a/sys/sys/lockf.h
+++ b/sys/sys/lockf.h
@@ -72,11 +72,11 @@ struct lockf {
 /* Maximum length of sleep chains to traverse to try and detect deadlock. */
 #define MAXDEPTH 50
 
-int	 lf_advlock __P((struct vop_advlock_args *, struct lockf **, u_quad_t));
+int	 lf_advlock(struct vop_advlock_args *, struct lockf **, u_quad_t);
 
 #ifdef LOCKF_DEBUG
-void	lf_print __P((char *, struct lockf *));
-void	lf_printlist __P((char *, struct lockf *));
+void	lf_print(char *, struct lockf *);
+void	lf_printlist(char *, struct lockf *);
 #endif
 
 #endif /* !_SYS_LOCKF_H_ */
diff --git a/sys/sys/lockmgr.h b/sys/sys/lockmgr.h
index da8d86e..9ba1884 100644
--- a/sys/sys/lockmgr.h
+++ b/sys/sys/lockmgr.h
@@ -199,25 +199,25 @@ struct lock {
 void dumplockinfo(struct lock *lkp);
 struct thread;
 
-void	lockinit __P((struct lock *, int prio, const char *wmesg,
-			int timo, int flags));
-void	lockdestroy __P((struct lock *));
+void	lockinit(struct lock *, int prio, const char *wmesg,
+			int timo, int flags);
+void	lockdestroy(struct lock *);
 
 #ifdef DEBUG_LOCKS
-int	debuglockmgr __P((struct lock *, u_int flags,
+int	debuglockmgr(struct lock *, u_int flags,
 			struct mtx *, struct thread *p,
 			const char *,
 			const char *,
-			int));
+			int);
 #define lockmgr(lockp, flags, slockp, proc) \
 	debuglockmgr((lockp), (flags), (slockp), (proc), \
 	    "lockmgr", __FILE__, __LINE__)
 #else
-int	lockmgr __P((struct lock *, u_int flags,
-			struct mtx *, struct thread *p));
+int	lockmgr(struct lock *, u_int flags,
+			struct mtx *, struct thread *p);
 #endif
-void	lockmgr_printinfo __P((struct lock *));
-int	lockstatus __P((struct lock *, struct thread *));
-int	lockcount __P((struct lock *));
+void	lockmgr_printinfo(struct lock *);
+int	lockstatus(struct lock *, struct thread *);
+int	lockcount(struct lock *);
 
 #endif /* !_SYS_LOCKMGR_H_ */
diff --git a/sys/sys/malloc.h b/sys/sys/malloc.h
index fa64f71..f14ef98 100644
--- a/sys/sys/malloc.h
+++ b/sys/sys/malloc.h
@@ -100,19 +100,19 @@ MALLOC_DECLARE(M_IP6NDP); /* for INET6 */
 MALLOC_DECLARE(M_IOV);
 
 /* XXX struct malloc_type is unused for contig*(). */
-void	contigfree __P((void *addr, unsigned long size,
-			struct malloc_type *type));
-void	*contigmalloc __P((unsigned long size, struct malloc_type *type,
+void	contigfree(void *addr, unsigned long size,
+			struct malloc_type *type);
+void	*contigmalloc(unsigned long size, struct malloc_type *type,
 			   int flags, unsigned long low, unsigned long high,
-			   unsigned long alignment, unsigned long boundary));
-void	free __P((void *addr, struct malloc_type *type));
-void	*malloc __P((unsigned long size, struct malloc_type *type, int flags));
-void	malloc_init __P((void *));
-void	malloc_uninit __P((void *));
-void	*realloc __P((void *addr, unsigned long size,
-		      struct malloc_type *type, int flags));
-void	*reallocf __P((void *addr, unsigned long size,
-		      struct malloc_type *type, int flags));
+			   unsigned long alignment, unsigned long boundary);
+void	free(void *addr, struct malloc_type *type);
+void	*malloc(unsigned long size, struct malloc_type *type, int flags);
+void	malloc_init(void *);
+void	malloc_uninit(void *);
+void	*realloc(void *addr, unsigned long size,
+		      struct malloc_type *type, int flags);
+void	*reallocf(void *addr, unsigned long size,
+		      struct malloc_type *type, int flags);
 #endif /* _KERNEL */
 
 #endif /* !_SYS_MALLOC_H_ */
diff --git a/sys/sys/md5.h b/sys/sys/md5.h
index 4211b01..3ffe2fe 100644
--- a/sys/sys/md5.h
+++ b/sys/sys/md5.h
@@ -45,7 +45,7 @@ char * MD5File(const char *, char *);
 char * MD5FileChunk(const char *, char *, off_t, off_t);
 char * MD5Data(const unsigned char *, unsigned int, char *);
 #ifdef _KERNEL
-void MD5Transform __P((u_int32_t [4], const unsigned char [64]));
+void MD5Transform(u_int32_t [4], const unsigned char [64]);
 #endif
 __END_DECLS
 #endif /* _SYS_MD5_H_ */
diff --git a/sys/sys/mman.h b/sys/sys/mman.h
index 7a9bd95..e63d2d8 100644
--- a/sys/sys/mman.h
+++ b/sys/sys/mman.h
@@ -136,24 +136,24 @@
 
 __BEGIN_DECLS
 #ifdef _P1003_1B_VISIBLE
-int	mlockall __P((int));
-int	munlockall __P((void));
-int	shm_open __P((const char *, int, mode_t));
-int	shm_unlink __P((const char *));
+int	mlockall(int);
+int	munlockall(void);
+int	shm_open(const char *, int, mode_t);
+int	shm_unlink(const char *);
 #endif /* _P1003_1B_VISIBLE */
-int	mlock __P((const void *, size_t));
+int	mlock(const void *, size_t);
 #ifndef _MMAP_DECLARED
 #define	_MMAP_DECLARED
-void *	mmap __P((void *, size_t, int, int, int, off_t));
+void *	mmap(void *, size_t, int, int, int, off_t);
 #endif
-int	mprotect __P((const void *, size_t, int));
-int	msync __P((void *, size_t, int));
-int	munlock __P((const void *, size_t));
-int	munmap __P((void *, size_t));
+int	mprotect(const void *, size_t, int);
+int	msync(void *, size_t, int);
+int	munlock(const void *, size_t);
+int	munmap(void *, size_t);
 #ifndef _POSIX_SOURCE
-int	madvise __P((void *, size_t, int));
-int	mincore __P((const void *, size_t, char *));
-int	minherit __P((void *, size_t, int));
+int	madvise(void *, size_t, int);
+int	mincore(const void *, size_t, char *);
+int	minherit(void *, size_t, int);
 #endif
 __END_DECLS
 
diff --git a/sys/sys/mount.h b/sys/sys/mount.h
index 505e034..3bcd1a9 100644
--- a/sys/sys/mount.h
+++ b/sys/sys/mount.h
@@ -345,32 +345,32 @@ struct mount_args;
 #endif
 
 struct vfsops {
-	int	(*vfs_mount)	__P((struct mount *mp, char *path, caddr_t data,
-				    struct nameidata *ndp, struct thread *td));
-	int	(*vfs_start)	__P((struct mount *mp, int flags,
-				    struct thread *td));
-	int	(*vfs_unmount)	__P((struct mount *mp, int mntflags,
-				    struct thread *td));
-	int	(*vfs_root)	__P((struct mount *mp, struct vnode **vpp));
-	int	(*vfs_quotactl)	__P((struct mount *mp, int cmds, uid_t uid,
-				    caddr_t arg, struct thread *td));
-	int	(*vfs_statfs)	__P((struct mount *mp, struct statfs *sbp,
-				    struct thread *td));
-	int	(*vfs_sync)	__P((struct mount *mp, int waitfor,
-				    struct ucred *cred, struct thread *td));
-	int	(*vfs_vget)	__P((struct mount *mp, ino_t ino, int flags,
-				    struct vnode **vpp));
-	int	(*vfs_fhtovp)	__P((struct mount *mp, struct fid *fhp,
-				    struct vnode **vpp));
-	int	(*vfs_checkexp) __P((struct mount *mp, struct sockaddr *nam,
-				    int *extflagsp, struct ucred **credanonp));
-	int	(*vfs_vptofh)	__P((struct vnode *vp, struct fid *fhp));
-	int	(*vfs_init)	__P((struct vfsconf *));
-	int	(*vfs_uninit)	__P((struct vfsconf *));
-	int	(*vfs_extattrctl) __P((struct mount *mp, int cmd,
+	int	(*vfs_mount)	(struct mount *mp, char *path, caddr_t data,
+				    struct nameidata *ndp, struct thread *td);
+	int	(*vfs_start)	(struct mount *mp, int flags,
+				    struct thread *td);
+	int	(*vfs_unmount)	(struct mount *mp, int mntflags,
+				    struct thread *td);
+	int	(*vfs_root)	(struct mount *mp, struct vnode **vpp);
+	int	(*vfs_quotactl)	(struct mount *mp, int cmds, uid_t uid,
+				    caddr_t arg, struct thread *td);
+	int	(*vfs_statfs)	(struct mount *mp, struct statfs *sbp,
+				    struct thread *td);
+	int	(*vfs_sync)	(struct mount *mp, int waitfor,
+				    struct ucred *cred, struct thread *td);
+	int	(*vfs_vget)	(struct mount *mp, ino_t ino, int flags,
+				    struct vnode **vpp);
+	int	(*vfs_fhtovp)	(struct mount *mp, struct fid *fhp,
+				    struct vnode **vpp);
+	int	(*vfs_checkexp)(struct mount *mp, struct sockaddr *nam,
+				    int *extflagsp, struct ucred **credanonp);
+	int	(*vfs_vptofh)	(struct vnode *vp, struct fid *fhp);
+	int	(*vfs_init)	(struct vfsconf *);
+	int	(*vfs_uninit)	(struct vfsconf *);
+	int	(*vfs_extattrctl)(struct mount *mp, int cmd,
 					struct vnode *filename_vp,
 					int attrnamespace, const char *attrname,
-					struct thread *td));
+					struct thread *td);
 };
 
 #define VFS_MOUNT(MP, PATH, DATA, NDP, P) \
@@ -413,31 +413,31 @@ extern	char *mountrootfsname;
 /*
  * exported vnode operations
  */
-int	dounmount __P((struct mount *, int, struct thread *td));
-int	vfs_mount __P((struct thread *td, const char *type, char *path,
-	    int flags, void *data));
+int	dounmount(struct mount *, int, struct thread *td);
+int	vfs_mount (struct thread *td, const char *type, char *path,
+	    int flags, void *data);
 int	vfs_setpublicfs			    /* set publicly exported fs */
-	  __P((struct mount *, struct netexport *, struct export_args *));
-int	vfs_lock __P((struct mount *));         /* lock a vfs */
-void	vfs_msync __P((struct mount *, int));
-void	vfs_unlock __P((struct mount *));       /* unlock a vfs */
-int	vfs_busy __P((struct mount *, int, struct mtx *, struct thread *td));
+	(struct mount *, struct netexport *, struct export_args *);
+int	vfs_lock(struct mount *);         /* lock a vfs */
+void	vfs_msync(struct mount *, int);
+void	vfs_unlock(struct mount *);       /* unlock a vfs */
+int	vfs_busy(struct mount *, int, struct mtx *, struct thread *td);
 int	vfs_export			 /* process mount export info */
-	  __P((struct mount *, struct export_args *));
+	(struct mount *, struct export_args *);
 struct	netcred *vfs_export_lookup	    /* lookup host in fs export list */
-	  __P((struct mount *, struct sockaddr *));
-int	vfs_allocate_syncvnode __P((struct mount *));
-void	vfs_getnewfsid __P((struct mount *));
-dev_t	vfs_getrootfsid __P((struct mount *));
-struct	mount *vfs_getvfs __P((fsid_t *));      /* return vfs given fsid */
-int	vfs_modevent __P((module_t, int, void *));
-int	vfs_mountedon __P((struct vnode *));    /* is a vfs mounted on vp */
-void	vfs_mountroot __P((void *));    /* mount our root filesystem */
-int	vfs_rootmountalloc __P((char *, char *, struct mount **));
-void	vfs_unbusy __P((struct mount *, struct thread *td));
-void	vfs_unmountall __P((void));
-int	vfs_register __P((struct vfsconf *));
-int	vfs_unregister __P((struct vfsconf *));
+	(struct mount *, struct sockaddr *);
+int	vfs_allocate_syncvnode(struct mount *);
+void	vfs_getnewfsid(struct mount *);
+dev_t	vfs_getrootfsid(struct mount *);
+struct	mount *vfs_getvfs(fsid_t *);      /* return vfs given fsid */
+int	vfs_modevent(module_t, int, void *);
+int	vfs_mountedon(struct vnode *);    /* is a vfs mounted on vp */
+void	vfs_mountroot(void *);    /* mount our root filesystem */
+int	vfs_rootmountalloc(char *, char *, struct mount **);
+void	vfs_unbusy(struct mount *, struct thread *td);
+void	vfs_unmountall(void);
+int	vfs_register(struct vfsconf *);
+int	vfs_unregister(struct vfsconf *);
 extern	TAILQ_HEAD(mntlist, mount) mountlist;	/* mounted filesystem list */
 extern	struct mtx mountlist_mtx;
 extern	struct nfs_public nfs_pub;
@@ -447,30 +447,30 @@ extern	struct nfs_public nfs_pub;
  * kern/vfs_default.c, they should be used instead of making "dummy" 
  * functions or casting entries in the VFS op table to "enopnotsupp()".
  */ 
-int	vfs_stdmount __P((struct mount *mp, char *path, caddr_t data, 
-		struct nameidata *ndp, struct thread *td));
-int	vfs_stdstart __P((struct mount *mp, int flags, struct thread *td));
-int	vfs_stdunmount __P((struct mount *mp, int mntflags, struct thread *td));
-int	vfs_stdroot __P((struct mount *mp, struct vnode **vpp));
-int	vfs_stdquotactl __P((struct mount *mp, int cmds, uid_t uid,
-		caddr_t arg, struct thread *td));
-int	vfs_stdstatfs __P((struct mount *mp, struct statfs *sbp, struct thread *td));
-int	vfs_stdsync __P((struct mount *mp, int waitfor, struct ucred *cred, 
-		struct thread *td));
-int	vfs_stdvget __P((struct mount *mp, ino_t ino, int, struct vnode **vpp));
-int	vfs_stdfhtovp __P((struct mount *mp, struct fid *fhp, struct vnode **vpp));
-int	vfs_stdcheckexp __P((struct mount *mp, struct sockaddr *nam,
-	   int *extflagsp, struct ucred **credanonp));
-int	vfs_stdvptofh __P((struct vnode *vp, struct fid *fhp));
-int	vfs_stdinit __P((struct vfsconf *));
-int	vfs_stduninit __P((struct vfsconf *));
-int	vfs_stdextattrctl __P((struct mount *mp, int cmd,
+int	vfs_stdmount(struct mount *mp, char *path, caddr_t data, 
+		struct nameidata *ndp, struct thread *td);
+int	vfs_stdstart(struct mount *mp, int flags, struct thread *td);
+int	vfs_stdunmount(struct mount *mp, int mntflags, struct thread *td);
+int	vfs_stdroot(struct mount *mp, struct vnode **vpp);
+int	vfs_stdquotactl(struct mount *mp, int cmds, uid_t uid,
+		caddr_t arg, struct thread *td);
+int	vfs_stdstatfs(struct mount *mp, struct statfs *sbp, struct thread *td);
+int	vfs_stdsync(struct mount *mp, int waitfor, struct ucred *cred, 
+		struct thread *td);
+int	vfs_stdvget(struct mount *mp, ino_t ino, int, struct vnode **vpp);
+int	vfs_stdfhtovp(struct mount *mp, struct fid *fhp, struct vnode **vpp);
+int	vfs_stdcheckexp(struct mount *mp, struct sockaddr *nam,
+	   int *extflagsp, struct ucred **credanonp);
+int	vfs_stdvptofh(struct vnode *vp, struct fid *fhp);
+int	vfs_stdinit(struct vfsconf *);
+int	vfs_stduninit(struct vfsconf *);
+int	vfs_stdextattrctl(struct mount *mp, int cmd,
 	    struct vnode *filename_vp, int attrnamespace, const char *attrname,
-	    struct thread *td));
+	    struct thread *td);
 
 /* XXX - these should be indirect functions!!! */
-int	softdep_process_worklist __P((struct mount *));
-int	softdep_fsync __P((struct vnode *));
+int	softdep_process_worklist(struct mount *);
+int	softdep_fsync(struct vnode *);
 #else /* !_KERNEL */
 
 #include <sys/cdefs.h>
@@ -478,27 +478,27 @@ int	softdep_fsync __P((struct vnode *));
 struct stat;
 
 __BEGIN_DECLS
-int	fhopen __P((const struct fhandle *, int));
-int	fhstat __P((const struct fhandle *, struct stat *));
-int	fhstatfs __P((const struct fhandle *, struct statfs *));
-int	fstatfs __P((int, struct statfs *));
-int	getfh __P((const char *, fhandle_t *));
-int	getfsstat __P((struct statfs *, long, int));
-int	getmntinfo __P((struct statfs **, int));
-int	mount __P((const char *, const char *, int, void *));
-int	statfs __P((const char *, struct statfs *));
-int	unmount __P((const char *, int));
+int	fhopen(const struct fhandle *, int);
+int	fhstat(const struct fhandle *, struct stat *);
+int	fhstatfs(const struct fhandle *, struct statfs *);
+int	fstatfs(int, struct statfs *);
+int	getfh(const char *, fhandle_t *);
+int	getfsstat(struct statfs *, long, int);
+int	getmntinfo(struct statfs **, int);
+int	mount(const char *, const char *, int, void *);
+int	statfs(const char *, struct statfs *);
+int	unmount(const char *, int);
 
 /* C library stuff */
-void	endvfsent __P((void));
-struct	ovfsconf *getvfsbyname __P((const char *));
-struct	ovfsconf *getvfsbytype __P((int));
-struct	ovfsconf *getvfsent __P((void));
+void	endvfsent(void);
+struct	ovfsconf *getvfsbyname(const char *);
+struct	ovfsconf *getvfsbytype(int);
+struct	ovfsconf *getvfsent(void);
 #define	getvfsbyname	new_getvfsbyname
-int	new_getvfsbyname __P((const char *, struct vfsconf *));
-void	setvfsent __P((int));
-int	vfsisloadable __P((const char *));
-int	vfsload __P((const char *));
+int	new_getvfsbyname(const char *, struct vfsconf *);
+void	setvfsent(int);
+int	vfsisloadable(const char *);
+int	vfsload(const char *);
 __END_DECLS
 
 #endif /* _KERNEL */
diff --git a/sys/sys/msg.h b/sys/sys/msg.h
index 7df1aef..b081245 100644
--- a/sys/sys/msg.h
+++ b/sys/sys/msg.h
@@ -95,11 +95,11 @@ extern struct msginfo	msginfo;
 #include <sys/cdefs.h>
 
 __BEGIN_DECLS
-int msgsys __P((int, ...));
-int msgctl __P((int, int, struct msqid_ds *));
-int msgget __P((key_t, int));
-int msgsnd __P((int, void *, size_t, int));
-int msgrcv __P((int, void*, size_t, long, int));
+int msgsys(int, ...);
+int msgctl(int, int, struct msqid_ds *);
+int msgget(key_t, int);
+int msgsnd(int, void *, size_t, int);
+int msgrcv(int, void*, size_t, long, int);
 __END_DECLS
 #endif
 
diff --git a/sys/sys/msgbuf.h b/sys/sys/msgbuf.h
index 3f192a9..8ffb5e3 100644
--- a/sys/sys/msgbuf.h
+++ b/sys/sys/msgbuf.h
@@ -49,7 +49,7 @@ struct msgbuf {
 #ifdef _KERNEL
 extern int	msgbuftrigger;
 extern struct	msgbuf *msgbufp;
-void	msgbufinit	__P((void *ptr, size_t size));
+void	msgbufinit	(void *ptr, size_t size);
 
 #if !defined(MSGBUF_SIZE)
 #define	MSGBUF_SIZE	32768
diff --git a/sys/sys/namei.h b/sys/sys/namei.h
index 1ae6120..4e0ba5c 100644
--- a/sys/sys/namei.h
+++ b/sys/sys/namei.h
@@ -149,8 +149,8 @@ struct nameidata {
 /*
  * Initialization of an nameidata structure.
  */
-static void NDINIT __P((struct nameidata *, u_long, u_long, enum uio_seg,
-	    const char *, struct thread *));
+static void NDINIT(struct nameidata *, u_long, u_long, enum uio_seg,
+	    const char *, struct thread *);
 static __inline void
 #if defined(__STDC__) || defined(__cplusplus)
 NDINIT(struct nameidata *ndp,
@@ -184,12 +184,12 @@ NDINIT(ndp, op, flags, segflg, namep, td)
 #define NDF_NO_FREE_PNBUF	0x00000020
 #define NDF_ONLY_PNBUF		(~NDF_NO_FREE_PNBUF)
 
-void NDFREE __P((struct nameidata *, const uint));
+void NDFREE(struct nameidata *, const uint);
 
-int	namei __P((struct nameidata *ndp));
-int	lookup __P((struct nameidata *ndp));
-int	relookup __P((struct vnode *dvp, struct vnode **vpp,
-	    struct componentname *cnp));
+int	namei(struct nameidata *ndp);
+int	lookup(struct nameidata *ndp);
+int	relookup(struct vnode *dvp, struct vnode **vpp,
+	    struct componentname *cnp);
 #endif
 
 /*
diff --git a/sys/sys/param.h b/sys/sys/param.h
index 295ba0a..2a00335 100644
--- a/sys/sys/param.h
+++ b/sys/sys/param.h
@@ -196,10 +196,10 @@
 #ifndef _BYTEORDER_PROTOTYPED
 #define	_BYTEORDER_PROTOTYPED
 __BEGIN_DECLS
-__uint32_t	 htonl __P((__uint32_t));
-__uint16_t	 htons __P((__uint16_t));
-__uint32_t	 ntohl __P((__uint32_t));
-__uint16_t	 ntohs __P((__uint16_t));
+__uint32_t	 htonl(__uint32_t);
+__uint16_t	 htons(__uint16_t);
+__uint32_t	 ntohl(__uint32_t);
+__uint16_t	 ntohs(__uint16_t);
 __END_DECLS
 #endif
 
diff --git a/sys/sys/poll.h b/sys/sys/poll.h
index b45aefb..7039ed9 100644
--- a/sys/sys/poll.h
+++ b/sys/sys/poll.h
@@ -103,7 +103,7 @@ __BEGIN_DECLS
  * XXX poll() has "unsigned long" nfds on SVR4, not unsigned as on the
  * other BSDs.
  */
-int	poll __P((struct pollfd *_pfd, unsigned int _nfds, int _timeout));
+int	poll(struct pollfd *_pfd, unsigned int _nfds, int _timeout);
 __END_DECLS
 
 #endif /* !_KERNEL */
diff --git a/sys/sys/proc.h b/sys/sys/proc.h
index 9250e31..509a44e 100644
--- a/sys/sys/proc.h
+++ b/sys/sys/proc.h
@@ -725,8 +725,8 @@ struct	proc *zpfind(pid_t);	/* Find zombie process by id. */
 void	ast(struct trapframe *framep);
 struct	thread *choosethread(void);
 int	cr_cansignal(struct ucred *cred, struct proc *proc, int signum);
-int	enterpgrp __P((struct proc *p, pid_t pgid, struct pgrp *pgrp, struct session *sess));
-int	enterthispgrp __P((struct proc *p, struct pgrp *pgrp));
+int	enterpgrp(struct proc *p, pid_t pgid, struct pgrp *pgrp, struct session *sess);
+int	enterthispgrp(struct proc *p, struct pgrp *pgrp);
 void	faultin(struct proc *p);
 void	fixjobc(struct proc *p, struct pgrp *pgrp, int entering);
 int	fork1(struct thread *, int, struct proc **);
diff --git a/sys/sys/protosw.h b/sys/sys/protosw.h
index 81ff300..eceef4f0 100644
--- a/sys/sys/protosw.h
+++ b/sys/sys/protosw.h
@@ -196,35 +196,31 @@ struct uio;
  * migrate this stuff back into the main structure.
  */
 struct pr_usrreqs {
-	int	(*pru_abort) __P((struct socket *so));
-	int	(*pru_accept) __P((struct socket *so, struct sockaddr **nam));
-	int	(*pru_attach) __P((struct socket *so, int proto,
-				   struct thread *td));
-	int	(*pru_bind) __P((struct socket *so, struct sockaddr *nam,
-				 struct thread *td));
-	int	(*pru_connect) __P((struct socket *so, struct sockaddr *nam,
-				    struct thread *td));
-	int	(*pru_connect2) __P((struct socket *so1, struct socket *so2));
-	int	(*pru_control) __P((struct socket *so, u_long cmd, caddr_t data,
-				    struct ifnet *ifp, struct thread *td));
-	int	(*pru_detach) __P((struct socket *so));
-	int	(*pru_disconnect) __P((struct socket *so));
-	int	(*pru_listen) __P((struct socket *so, struct thread *td));
-	int	(*pru_peeraddr) __P((struct socket *so, 
-				     struct sockaddr **nam));
-	int	(*pru_rcvd) __P((struct socket *so, int flags));
-	int	(*pru_rcvoob) __P((struct socket *so, struct mbuf *m,
-				   int flags));
-	int	(*pru_send) __P((struct socket *so, int flags, struct mbuf *m, 
+	int	(*pru_abort)(struct socket *so);
+	int	(*pru_accept)(struct socket *so, struct sockaddr **nam);
+	int	(*pru_attach)(struct socket *so, int proto, struct thread *td);
+	int	(*pru_bind)(struct socket *so, struct sockaddr *nam,
+				 struct thread *td);
+	int	(*pru_connect)(struct socket *so, struct sockaddr *nam,
+				    struct thread *td);
+	int	(*pru_connect2)(struct socket *so1, struct socket *so2);
+	int	(*pru_control)(struct socket *so, u_long cmd, caddr_t data,
+				    struct ifnet *ifp, struct thread *td);
+	int	(*pru_detach)(struct socket *so);
+	int	(*pru_disconnect)(struct socket *so);
+	int	(*pru_listen)(struct socket *so, struct thread *td);
+	int	(*pru_peeraddr)(struct socket *so, struct sockaddr **nam);
+	int	(*pru_rcvd)(struct socket *so, int flags);
+	int	(*pru_rcvoob)(struct socket *so, struct mbuf *m, int flags);
+	int	(*pru_send)(struct socket *so, int flags, struct mbuf *m, 
 				 struct sockaddr *addr, struct mbuf *control,
-				 struct thread *td));
+				 struct thread *td);
 #define	PRUS_OOB	0x1
 #define	PRUS_EOF	0x2
 #define	PRUS_MORETOCOME	0x4
-	int	(*pru_sense) __P((struct socket *so, struct stat *sb));
-	int	(*pru_shutdown) __P((struct socket *so));
-	int	(*pru_sockaddr) __P((struct socket *so, 
-				     struct sockaddr **nam));
+	int	(*pru_sense)(struct socket *so, struct stat *sb);
+	int	(*pru_shutdown)(struct socket *so);
+	int	(*pru_sockaddr)(struct socket *so, struct sockaddr **nam);
 	 
 	/*
 	 * These three added later, so they are out of order.  They are used
@@ -234,28 +230,28 @@ struct pr_usrreqs {
 	 * through these entry points.  For protocols which still use
 	 * the generic code, these just point to those routines.
 	 */
-	int	(*pru_sosend) __P((struct socket *so, struct sockaddr *addr,
+	int	(*pru_sosend)(struct socket *so, struct sockaddr *addr,
 				   struct uio *uio, struct mbuf *top,
 				   struct mbuf *control, int flags,
-				   struct thread *td));
-	int	(*pru_soreceive) __P((struct socket *so, 
+				   struct thread *td);
+	int	(*pru_soreceive)(struct socket *so, 
 				      struct sockaddr **paddr,
 				      struct uio *uio, struct mbuf **mp0,
-				      struct mbuf **controlp, int *flagsp));
-	int	(*pru_sopoll) __P((struct socket *so, int events,
-				     struct ucred *cred, struct thread *td));
+				      struct mbuf **controlp, int *flagsp);
+	int	(*pru_sopoll)(struct socket *so, int events,
+				     struct ucred *cred, struct thread *td);
 };
 
-int	pru_accept_notsupp __P((struct socket *so, struct sockaddr **nam));
-int	pru_connect_notsupp __P((struct socket *so, struct sockaddr *nam,
-				 struct thread *td));
-int	pru_connect2_notsupp __P((struct socket *so1, struct socket *so2));
-int	pru_control_notsupp __P((struct socket *so, u_long cmd, caddr_t data,
-				 struct ifnet *ifp, struct thread *td));
-int	pru_listen_notsupp __P((struct socket *so, struct thread *td));
-int	pru_rcvd_notsupp __P((struct socket *so, int flags));
-int	pru_rcvoob_notsupp __P((struct socket *so, struct mbuf *m, int flags));
-int	pru_sense_null __P((struct socket *so, struct stat *sb));
+int	pru_accept_notsupp(struct socket *so, struct sockaddr **nam);
+int	pru_connect_notsupp(struct socket *so, struct sockaddr *nam,
+				 struct thread *td);
+int	pru_connect2_notsupp(struct socket *so1, struct socket *so2);
+int	pru_control_notsupp(struct socket *so, u_long cmd, caddr_t data,
+				 struct ifnet *ifp, struct thread *td);
+int	pru_listen_notsupp(struct socket *so, struct thread *td);
+int	pru_rcvd_notsupp(struct socket *so, int flags);
+int	pru_rcvoob_notsupp(struct socket *so, struct mbuf *m, int flags);
+int	pru_sense_null(struct socket *so, struct stat *sb);
 
 #endif /* _KERNEL */
 
@@ -329,10 +325,10 @@ char	*prcorequests[] = {
 #endif
 
 #ifdef _KERNEL
-void	pfctlinput __P((int, struct sockaddr *));
-void	pfctlinput2 __P((int, struct sockaddr *, void *));
-struct protosw *pffindproto __P((int family, int protocol, int type));
-struct protosw *pffindtype __P((int family, int type));
+void	pfctlinput(int, struct sockaddr *);
+void	pfctlinput2(int, struct sockaddr *, void *);
+struct protosw *pffindproto(int family, int protocol, int type);
+struct protosw *pffindtype(int family, int type);
 #endif
 
 #endif
diff --git a/sys/sys/queue.h b/sys/sys/queue.h
index dc5c2ba..3d86d0c 100644
--- a/sys/sys/queue.h
+++ b/sys/sys/queue.h
@@ -443,8 +443,8 @@ remque(void *a)
 
 #else /* !__GNUC__ */
 
-void	insque __P((void *a, void *b));
-void	remque __P((void *a));
+void	insque(void *a, void *b);
+void	remque(void *a);
 
 #endif /* __GNUC__ */
 
diff --git a/sys/sys/regression.h b/sys/sys/regression.h
index 39cacd1..d9170bc 100644
--- a/sys/sys/regression.h
+++ b/sys/sys/regression.h
@@ -32,7 +32,7 @@
 /*
  * System calls associated with regression testing functions in kernel.
  */
-int	__setugid __P ((int _flag));
+int	__setugid(int _flag);
 #endif /* !_KERNEL */
 
 #endif /* !_SYS_REGRESSION_H */
diff --git a/sys/sys/resource.h b/sys/sys/resource.h
index 2d868f3..b723781 100644
--- a/sys/sys/resource.h
+++ b/sys/sys/resource.h
@@ -135,17 +135,17 @@ struct loadavg {
 #ifdef _KERNEL
 extern struct loadavg averunnable;
 
-int	dosetrlimit __P((struct thread *, u_int, struct rlimit *));
+int	dosetrlimit(struct thread *, u_int, struct rlimit *);
 
 #else
 #include <sys/cdefs.h>
 
 __BEGIN_DECLS
-int	getpriority __P((int, int));
-int	getrlimit __P((int, struct rlimit *));
-int	getrusage __P((int, struct rusage *));
-int	setpriority __P((int, int, int));
-int	setrlimit __P((int, const struct rlimit *));
+int	getpriority(int, int);
+int	getrlimit(int, struct rlimit *);
+int	getrusage(int, struct rusage *);
+int	setpriority(int, int, int);
+int	setrlimit(int, const struct rlimit *);
 __END_DECLS
 
 #endif	/* _KERNEL */
diff --git a/sys/sys/resourcevar.h b/sys/sys/resourcevar.h
index aa7cbf9..8344c91 100644
--- a/sys/sys/resourcevar.h
+++ b/sys/sys/resourcevar.h
@@ -106,23 +106,23 @@ struct thread;
 struct kse;
 struct proc;
 
-void	 addupc_intr __P((struct kse *ke, uintptr_t pc, u_int ticks));
-void	 addupc_task __P((struct kse *ke, uintptr_t pc, u_int ticks));
-void	 calcru __P((struct proc *p, struct timeval *up, struct timeval *sp,
-	    struct timeval *ip));
-int	 chgproccnt __P((struct uidinfo *uip, int diff, int max));
-int	 chgsbsize __P((struct uidinfo *uip, u_long *hiwat, u_long to,
-	    rlim_t max));
-int	 fuswintr __P((void *base));
+void	 addupc_intr(struct kse *ke, uintptr_t pc, u_int ticks);
+void	 addupc_task(struct kse *ke, uintptr_t pc, u_int ticks);
+void	 calcru(struct proc *p, struct timeval *up, struct timeval *sp,
+	    struct timeval *ip);
+int	 chgproccnt(struct uidinfo *uip, int diff, int max);
+int	 chgsbsize(struct uidinfo *uip, u_long *hiwat, u_long to,
+	    rlim_t max);
+int	 fuswintr(void *base);
 struct plimit
-	*limcopy __P((struct plimit *lim));
-void	 ruadd __P((struct rusage *ru, struct rusage *ru2));
-int	 suswintr __P((void *base, int word));
+	*limcopy(struct plimit *lim);
+void	 ruadd(struct rusage *ru, struct rusage *ru2);
+int	 suswintr(void *base, int word);
 struct uidinfo
-	*uifind __P((uid_t uid));
-void	 uihold __P((struct uidinfo *uip));
-void	 uifree __P((struct uidinfo *uip));
-void	uihashinit __P((void));
+	*uifind(uid_t uid);
+void	 uihold(struct uidinfo *uip);
+void	 uifree(struct uidinfo *uip);
+void	uihashinit(void);
 #endif
 
 #endif	/* !_SYS_RESOURCEVAR_H_ */
diff --git a/sys/sys/rtprio.h b/sys/sys/rtprio.h
index 97ad469..f4e44a9 100644
--- a/sys/sys/rtprio.h
+++ b/sys/sys/rtprio.h
@@ -85,7 +85,7 @@ void	pri_to_rtp(struct ksegrp *, struct rtprio *);
 #include <sys/cdefs.h>
 
 __BEGIN_DECLS
-int	rtprio __P((int, pid_t, struct rtprio *));
+int	rtprio(int, pid_t, struct rtprio *);
 __END_DECLS
 #endif	/* !_KERNEL */
 #endif	/* !_SYS_RTPRIO_H_ */
diff --git a/sys/sys/selinfo.h b/sys/sys/selinfo.h
index e51f645..9a03949 100644
--- a/sys/sys/selinfo.h
+++ b/sys/sys/selinfo.h
@@ -56,8 +56,8 @@ struct selinfo {
 
 #ifdef _KERNEL
 void	clear_selinfo_list(struct thread *td);
-void	selrecord __P((struct thread *selector, struct selinfo *sip));
-void	selwakeup __P((struct selinfo *sip));
+void	selrecord(struct thread *selector, struct selinfo *sip);
+void	selwakeup(struct selinfo *sip);
 #endif
 
 #endif /* !_SYS_SELINFO_H_ */
diff --git a/sys/sys/sem.h b/sys/sys/sem.h
index 4e63364..7f6a818 100644
--- a/sys/sys/sem.h
+++ b/sys/sys/sem.h
@@ -91,17 +91,17 @@ extern struct seminfo	seminfo;
 /*
  * Process sem_undo vectors at proc exit.
  */
-void	semexit __P((struct proc *p));
+void	semexit(struct proc *p);
 #endif /* _KERNEL */
 
 #ifndef _KERNEL
 #include <sys/cdefs.h>
 
 __BEGIN_DECLS
-int semsys __P((int, ...));
-int semctl __P((int, int, int, ...));
-int semget __P((key_t, int, int));
-int semop __P((int, struct sembuf *,unsigned));
+int semsys(int, ...);
+int semctl(int, int, int, ...);
+int semget(key_t, int, int);
+int semop(int, struct sembuf *,unsigned);
 __END_DECLS
 #endif /* !_KERNEL */
 
diff --git a/sys/sys/shm.h b/sys/sys/shm.h
index 024c0e5..b5ce766 100644
--- a/sys/sys/shm.h
+++ b/sys/sys/shm.h
@@ -98,18 +98,18 @@ struct shm_info {
 struct thread;
 struct proc;
 
-void	shmexit __P((struct proc *));
-void	shmfork __P((struct proc *, struct proc *));
+void	shmexit(struct proc *);
+void	shmfork(struct proc *, struct proc *);
 #else /* !_KERNEL */
 
 #include <sys/cdefs.h>
 
 __BEGIN_DECLS
-int shmsys __P((int, ...));
-void *shmat  __P((int, void *, int));
-int shmget __P((key_t, int, int));
-int shmctl __P((int, int, struct shmid_ds *));
-int shmdt  __P((void *));
+int shmsys(int, ...);
+void *shmat(int, void *, int);
+int shmget(key_t, int, int);
+int shmctl(int, int, struct shmid_ds *);
+int shmdt(void *);
 __END_DECLS
 
 #endif /* !_KERNEL */
diff --git a/sys/sys/signal.h b/sys/sys/signal.h
index b1ae12b..c658e28 100644
--- a/sys/sys/signal.h
+++ b/sys/sys/signal.h
@@ -119,7 +119,7 @@
  * have the same calling protocol so there is no problem in practice.
  * A bit in sa_flags could be used to specify the number of args.
  */
-typedef void __sighandler_t __P((int));
+typedef void __sighandler_t(int);
 
 #define	SIG_DFL		((__sighandler_t *)0)
 #define	SIG_IGN		((__sighandler_t *)1)
@@ -186,9 +186,8 @@ struct __siginfo;
  */
 struct sigaction {
 	union {
-		void    (*__sa_handler) __P((int));
-		void    (*__sa_sigaction) __P((int, struct __siginfo *,
-					       void *));
+		void    (*__sa_handler)(int);
+		void    (*__sa_sigaction)(int, struct __siginfo *, void *);
 	} __sigaction_u;		/* signal handler */
 	int	sa_flags;		/* see signal options below */
 	sigset_t sa_mask;		/* signal mask to apply */
@@ -225,7 +224,7 @@ struct sigaction {
 /* Additional FreeBSD values. */
 #define SI_UNDEFINED	0
 
-typedef void __siginfohandler_t __P((int, struct __siginfo *, void *));
+typedef void __siginfohandler_t(int, struct __siginfo *, void *);
 
 typedef	__sighandler_t	*sig_t;	/* type of pointer to a signal function */
 
@@ -303,7 +302,7 @@ struct sigstack {
  * defined by <sys/signal.h>.
  */
 __BEGIN_DECLS
-__sighandler_t *signal __P((int, __sighandler_t *));
+__sighandler_t *signal(int, __sighandler_t *);
 __END_DECLS
 
 #endif	/* !_SYS_SIGNAL_H_ */
diff --git a/sys/sys/signalvar.h b/sys/sys/signalvar.h
index 2105bc3..19abed3 100644
--- a/sys/sys/signalvar.h
+++ b/sys/sys/signalvar.h
@@ -73,14 +73,14 @@ typedef struct {
 
 struct osigaction {
 	union {
-		void    (*__sa_handler) __P((int));
-		void    (*__sa_sigaction) __P((int, osiginfo_t *, void *));
+		void    (*__sa_handler)(int);
+		void    (*__sa_sigaction)(int, osiginfo_t *, void *);
 	} __sigaction_u;		/* signal handler */
 	osigset_t	sa_mask;	/* signal mask to apply */
 	int		sa_flags;	/* see signal options below */
 };
 
-typedef void __osiginfohandler_t __P((int, osiginfo_t *, void *));
+typedef void __osiginfohandler_t(int, osiginfo_t *, void *);
 #endif /* _KERNEL */
 
 /* additional signal action values, used only temporarily/internally */
@@ -200,22 +200,22 @@ extern int sugid_coredump;	/* Sysctl variable kern.sugid_coredump */
  * Machine-independent functions:
  */
 int	CURSIG(struct proc *p);
-void	execsigs __P((struct proc *p));
-void	gsignal __P((int pgid, int sig));
-int	issignal __P((struct proc *p));
-void	killproc __P((struct proc *p, char *why));
-void	pgsigio __P((struct sigio *, int signum, int checkctty));
-void	pgsignal __P((struct pgrp *pgrp, int sig, int checkctty));
-void	postsig __P((int sig));
-void	psignal __P((struct proc *p, int sig));
-void	sigexit __P((struct thread *td, int signum)) __dead2;
-void	siginit __P((struct proc *p));
-void	trapsignal __P((struct proc *p, int sig, u_long code));
+void	execsigs(struct proc *p);
+void	gsignal(int pgid, int sig);
+int	issignal(struct proc *p);
+void	killproc(struct proc *p, char *why);
+void	pgsigio(struct sigio *, int signum, int checkctty);
+void	pgsignal(struct pgrp *pgrp, int sig, int checkctty);
+void	postsig(int sig);
+void	psignal(struct proc *p, int sig);
+void	sigexit(struct thread *td, int signum) __dead2;
+void	siginit(struct proc *p);
+void	trapsignal(struct proc *p, int sig, u_long code);
 
 /*
  * Machine-dependent functions:
  */
-void	sendsig __P((sig_t action, int sig, sigset_t *retmask, u_long code));
+void	sendsig(sig_t action, int sig, sigset_t *retmask, u_long code);
 
 #endif /* _KERNEL */
 
diff --git a/sys/sys/socket.h b/sys/sys/socket.h
index 2fce108..86f78dd 100644
--- a/sys/sys/socket.h
+++ b/sys/sys/socket.h
@@ -441,25 +441,25 @@ struct sf_hdtr {
 #include <sys/cdefs.h>
 
 __BEGIN_DECLS
-int	accept __P((int, struct sockaddr *, socklen_t *));
-int	bind __P((int, const struct sockaddr *, socklen_t));
-int	connect __P((int, const struct sockaddr *, socklen_t));
-int	getpeername __P((int, struct sockaddr *, socklen_t *));
-int	getsockname __P((int, struct sockaddr *, socklen_t *));
-int	getsockopt __P((int, int, int, void *, socklen_t *));
-int	listen __P((int, int));
-ssize_t	recv __P((int, void *, size_t, int));
-ssize_t	recvfrom __P((int, void *, size_t, int, struct sockaddr *, socklen_t *));
-ssize_t	recvmsg __P((int, struct msghdr *, int));
-ssize_t	send __P((int, const void *, size_t, int));
-ssize_t	sendto __P((int, const void *,
-	    size_t, int, const struct sockaddr *, socklen_t));
-ssize_t	sendmsg __P((int, const struct msghdr *, int));
-int	sendfile __P((int, int, off_t, size_t, struct sf_hdtr *, off_t *, int));
-int	setsockopt __P((int, int, int, const void *, socklen_t));
-int	shutdown __P((int, int));
-int	socket __P((int, int, int));
-int	socketpair __P((int, int, int, int *));
+int	accept(int, struct sockaddr *, socklen_t *);
+int	bind(int, const struct sockaddr *, socklen_t);
+int	connect(int, const struct sockaddr *, socklen_t);
+int	getpeername(int, struct sockaddr *, socklen_t *);
+int	getsockname(int, struct sockaddr *, socklen_t *);
+int	getsockopt(int, int, int, void *, socklen_t *);
+int	listen(int, int);
+ssize_t	recv(int, void *, size_t, int);
+ssize_t	recvfrom(int, void *, size_t, int, struct sockaddr *, socklen_t *);
+ssize_t	recvmsg(int, struct msghdr *, int);
+ssize_t	send(int, const void *, size_t, int);
+ssize_t	sendto(int, const void *,
+	    size_t, int, const struct sockaddr *, socklen_t);
+ssize_t	sendmsg(int, const struct msghdr *, int);
+int	sendfile(int, int, off_t, size_t, struct sf_hdtr *, off_t *, int);
+int	setsockopt(int, int, int, const void *, socklen_t);
+int	shutdown(int, int);
+int	socket(int, int, int);
+int	socketpair(int, int, int, int *);
 __END_DECLS
 
 #endif /* !_KERNEL */
diff --git a/sys/sys/socketvar.h b/sys/sys/socketvar.h
index 940c325..ade0a5c 100644
--- a/sys/sys/socketvar.h
+++ b/sys/sys/socketvar.h
@@ -111,7 +111,7 @@ struct socket {
 #define SB_AIO		0x80		/* AIO operations queued */
 #define SB_KNOTE	0x100		/* kernel note attached */
 
-	void	(*so_upcall) __P((struct socket *, void *, int));
+	void	(*so_upcall)(struct socket *, void *, int);
 	void	*so_upcallarg;
 	struct	ucred *so_cred;		/* user credentials */
 	/* NB: generation count must not be first; easiest to make it last. */
@@ -304,11 +304,11 @@ struct sf_buf {
 struct accept_filter {
 	char	accf_name[16];
 	void	(*accf_callback)
-		__P((struct socket *so, void *arg, int waitflag));
+		(struct socket *so, void *arg, int waitflag);
 	void *	(*accf_create)
-		__P((struct socket *so, char *arg));
+		(struct socket *so, char *arg);
 	void	(*accf_destroy)
-		__P((struct socket *so));
+		(struct socket *so);
 	SLIST_ENTRY(accept_filter) accf_next;	/* next on the list */
 };
 
@@ -335,103 +335,103 @@ struct knote;
 /*
  * File operations on sockets.
  */
-int	soo_read __P((struct file *fp, struct uio *uio, struct ucred *cred,
-	    int flags, struct thread *td));
-int	soo_write __P((struct file *fp, struct uio *uio, struct ucred *cred,
-	    int flags, struct thread *td));
-int	soo_close __P((struct file *fp, struct thread *td));
-int	soo_ioctl __P((struct file *fp, u_long cmd, caddr_t data,
-	    struct thread *td));
-int	soo_poll __P((struct file *fp, int events, struct ucred *cred,
-	    struct thread *td));
-int	soo_stat __P((struct file *fp, struct stat *ub, struct thread *td));
-int	sokqfilter __P((struct file *fp, struct knote *kn));
+int	soo_read(struct file *fp, struct uio *uio, struct ucred *cred,
+	    int flags, struct thread *td);
+int	soo_write(struct file *fp, struct uio *uio, struct ucred *cred,
+	    int flags, struct thread *td);
+int	soo_close(struct file *fp, struct thread *td);
+int	soo_ioctl(struct file *fp, u_long cmd, caddr_t data,
+	    struct thread *td);
+int	soo_poll(struct file *fp, int events, struct ucred *cred,
+	    struct thread *td);
+int	soo_stat(struct file *fp, struct stat *ub, struct thread *td);
+int	sokqfilter(struct file *fp, struct knote *kn);
 
 /*
  * From uipc_socket and friends
  */
-struct	sockaddr *dup_sockaddr __P((struct sockaddr *sa, int canwait));
-int	sockargs __P((struct mbuf **mp, caddr_t buf, int buflen, int type));
-int	getsockaddr __P((struct sockaddr **namp, caddr_t uaddr, size_t len));
-void	sbappend __P((struct sockbuf *sb, struct mbuf *m));
-int	sbappendaddr __P((struct sockbuf *sb, struct sockaddr *asa,
-	    struct mbuf *m0, struct mbuf *control));
-int	sbappendcontrol __P((struct sockbuf *sb, struct mbuf *m0,
-	    struct mbuf *control));
-void	sbappendrecord __P((struct sockbuf *sb, struct mbuf *m0));
-void	sbcheck __P((struct sockbuf *sb));
-void	sbcompress __P((struct sockbuf *sb, struct mbuf *m, struct mbuf *n));
+struct	sockaddr *dup_sockaddr(struct sockaddr *sa, int canwait);
+int	sockargs(struct mbuf **mp, caddr_t buf, int buflen, int type);
+int	getsockaddr(struct sockaddr **namp, caddr_t uaddr, size_t len);
+void	sbappend(struct sockbuf *sb, struct mbuf *m);
+int	sbappendaddr(struct sockbuf *sb, struct sockaddr *asa,
+	    struct mbuf *m0, struct mbuf *control);
+int	sbappendcontrol(struct sockbuf *sb, struct mbuf *m0,
+	    struct mbuf *control);
+void	sbappendrecord(struct sockbuf *sb, struct mbuf *m0);
+void	sbcheck(struct sockbuf *sb);
+void	sbcompress(struct sockbuf *sb, struct mbuf *m, struct mbuf *n);
 struct mbuf *
-	sbcreatecontrol __P((caddr_t p, int size, int type, int level));
-void	sbdrop __P((struct sockbuf *sb, int len));
-void	sbdroprecord __P((struct sockbuf *sb));
-void	sbflush __P((struct sockbuf *sb));
-void	sbinsertoob __P((struct sockbuf *sb, struct mbuf *m0));
-void	sbrelease __P((struct sockbuf *sb, struct socket *so));
-int	sbreserve __P((struct sockbuf *sb, u_long cc, struct socket *so,
-		       struct thread *td));
-void	sbtoxsockbuf __P((struct sockbuf *sb, struct xsockbuf *xsb));
-int	sbwait __P((struct sockbuf *sb));
-int	sb_lock __P((struct sockbuf *sb));
-int	soabort __P((struct socket *so));
-int	soaccept __P((struct socket *so, struct sockaddr **nam));
-struct	socket *soalloc __P((int waitok));
-int	sobind __P((struct socket *so, struct sockaddr *nam, struct thread *td));
-void	socantrcvmore __P((struct socket *so));
-void	socantsendmore __P((struct socket *so));
-int	soclose __P((struct socket *so));
-int	soconnect __P((struct socket *so, struct sockaddr *nam, struct thread *td));
-int	soconnect2 __P((struct socket *so1, struct socket *so2));
-int	socreate __P((int dom, struct socket **aso, int type, int proto,
-	    struct ucred *cred, struct thread *td));
-int	sodisconnect __P((struct socket *so));
-void	sofree __P((struct socket *so));
-int	sogetopt __P((struct socket *so, struct sockopt *sopt));
-void	sohasoutofband __P((struct socket *so));
-void	soisconnected __P((struct socket *so));
-void	soisconnecting __P((struct socket *so));
-void	soisdisconnected __P((struct socket *so));
-void	soisdisconnecting __P((struct socket *so));
-int	solisten __P((struct socket *so, int backlog, struct thread *td));
+	sbcreatecontrol(caddr_t p, int size, int type, int level);
+void	sbdrop(struct sockbuf *sb, int len);
+void	sbdroprecord(struct sockbuf *sb);
+void	sbflush(struct sockbuf *sb);
+void	sbinsertoob(struct sockbuf *sb, struct mbuf *m0);
+void	sbrelease(struct sockbuf *sb, struct socket *so);
+int	sbreserve(struct sockbuf *sb, u_long cc, struct socket *so,
+		       struct thread *td);
+void	sbtoxsockbuf(struct sockbuf *sb, struct xsockbuf *xsb);
+int	sbwait(struct sockbuf *sb);
+int	sb_lock(struct sockbuf *sb);
+int	soabort(struct socket *so);
+int	soaccept(struct socket *so, struct sockaddr **nam);
+struct	socket *soalloc(int waitok);
+int	sobind(struct socket *so, struct sockaddr *nam, struct thread *td);
+void	socantrcvmore(struct socket *so);
+void	socantsendmore(struct socket *so);
+int	soclose(struct socket *so);
+int	soconnect(struct socket *so, struct sockaddr *nam, struct thread *td);
+int	soconnect2(struct socket *so1, struct socket *so2);
+int	socreate(int dom, struct socket **aso, int type, int proto,
+	    struct ucred *cred, struct thread *td);
+int	sodisconnect(struct socket *so);
+void	sofree(struct socket *so);
+int	sogetopt(struct socket *so, struct sockopt *sopt);
+void	sohasoutofband(struct socket *so);
+void	soisconnected(struct socket *so);
+void	soisconnecting(struct socket *so);
+void	soisdisconnected(struct socket *so);
+void	soisdisconnecting(struct socket *so);
+int	solisten(struct socket *so, int backlog, struct thread *td);
 struct socket *
-	sodropablereq __P((struct socket *head));
+	sodropablereq(struct socket *head);
 struct socket *
-	sonewconn __P((struct socket *head, int connstatus));
-int	sooptcopyin __P((struct sockopt *sopt, void *buf, size_t len,
-			 size_t minlen));
-int	sooptcopyout __P((struct sockopt *sopt, void *buf, size_t len));
+	sonewconn(struct socket *head, int connstatus);
+int	sooptcopyin(struct sockopt *sopt, void *buf, size_t len,
+			 size_t minlen);
+int	sooptcopyout(struct sockopt *sopt, void *buf, size_t len);
 
 /* XXX; prepare mbuf for (__FreeBSD__ < 3) routines. */
-int	soopt_getm __P((struct sockopt *sopt, struct mbuf **mp));
-int	soopt_mcopyin __P((struct sockopt *sopt, struct mbuf *m));
-int	soopt_mcopyout __P((struct sockopt *sopt, struct mbuf *m));
+int	soopt_getm(struct sockopt *sopt, struct mbuf **mp);
+int	soopt_mcopyin(struct sockopt *sopt, struct mbuf *m);
+int	soopt_mcopyout(struct sockopt *sopt, struct mbuf *m);
 
-int	sopoll __P((struct socket *so, int events, struct ucred *cred,
-		    struct thread *td));
-int	soreceive __P((struct socket *so, struct sockaddr **paddr,
+int	sopoll(struct socket *so, int events, struct ucred *cred,
+		    struct thread *td);
+int	soreceive(struct socket *so, struct sockaddr **paddr,
 		       struct uio *uio, struct mbuf **mp0,
-		       struct mbuf **controlp, int *flagsp));
-int	soreserve __P((struct socket *so, u_long sndcc, u_long rcvcc));
-void	sorflush __P((struct socket *so));
-int	sosend __P((struct socket *so, struct sockaddr *addr, struct uio *uio,
+		       struct mbuf **controlp, int *flagsp);
+int	soreserve(struct socket *so, u_long sndcc, u_long rcvcc);
+void	sorflush(struct socket *so);
+int	sosend(struct socket *so, struct sockaddr *addr, struct uio *uio,
 		    struct mbuf *top, struct mbuf *control, int flags,
-		    struct thread *td));
-int	sosetopt __P((struct socket *so, struct sockopt *sopt));
-int	soshutdown __P((struct socket *so, int how));
-void	sotoxsocket __P((struct socket *so, struct xsocket *xso));
-void	sowakeup __P((struct socket *so, struct sockbuf *sb));
+		    struct thread *td);
+int	sosetopt(struct socket *so, struct sockopt *sopt);
+int	soshutdown(struct socket *so, int how);
+void	sotoxsocket(struct socket *so, struct xsocket *xso);
+void	sowakeup(struct socket *so, struct sockbuf *sb);
 
 /* accept filter functions */
-int	accept_filt_add __P((struct accept_filter *filt));
-int	accept_filt_del __P((char *name));
-struct accept_filter *	accept_filt_get __P((char *name));
+int	accept_filt_add(struct accept_filter *filt);
+int	accept_filt_del(char *name);
+struct accept_filter *	accept_filt_get(char *name);
 #ifdef ACCEPT_FILTER_MOD
-int accept_filt_generic_mod_event __P((module_t mod, int event, void *data));
+int accept_filt_generic_mod_event(module_t mod, int event, void *data);
 SYSCTL_DECL(_net_inet_accf);
 #endif /* ACCEPT_FILTER_MOD */
 
-int	socheckuid __P((struct socket *so, uid_t uid));
-int	socheckproc __P((struct socket *so, struct proc *p));
+int	socheckuid(struct socket *so, uid_t uid);
+int	socheckproc(struct socket *so, struct proc *p);
 
 #endif /* _KERNEL */
 
diff --git a/sys/sys/soundcard.h b/sys/sys/soundcard.h
index c3c2fe9..620d657 100644
--- a/sys/sys/soundcard.h
+++ b/sys/sys/soundcard.h
@@ -1127,7 +1127,7 @@ typedef struct copr_msg {
  */
 
 #ifndef USE_SIMPLE_MACROS
-void seqbuf_dump __P((void));	/* This function must be provided by programs */
+void seqbuf_dump(void);	/* This function must be provided by programs */
 
 /* Sample seqbuf_dump() implementation:
  *
diff --git a/sys/sys/stat.h b/sys/sys/stat.h
index 8a03251..a53960d 100644
--- a/sys/sys/stat.h
+++ b/sys/sys/stat.h
@@ -246,19 +246,19 @@ struct nstat {
 
 #ifndef _KERNEL
 __BEGIN_DECLS
-int	chmod __P((const char *, mode_t));
-int	fstat __P((int, struct stat *));
-int	mkdir __P((const char *, mode_t));
-int	mkfifo __P((const char *, mode_t));
-int	stat __P((const char *, struct stat *));
-mode_t	umask __P((mode_t));
+int	chmod(const char *, mode_t);
+int	fstat(int, struct stat *);
+int	mkdir(const char *, mode_t);
+int	mkfifo(const char *, mode_t);
+int	stat(const char *, struct stat *);
+mode_t	umask(mode_t);
 
 #ifndef _POSIX_SOURCE
-int	chflags __P((const char *, u_long));
-int	fchflags __P((int, u_long));
-int	fchmod __P((int, mode_t));
-int	lchmod __P((const char *, mode_t));
-int	lstat __P((const char *, struct stat *));
+int	chflags(const char *, u_long);
+int	fchflags(int, u_long);
+int	fchmod(int, mode_t);
+int	lchmod(const char *, mode_t);
+int	lstat(const char *, struct stat *);
 #endif
 __END_DECLS
 
diff --git a/sys/sys/sysctl.h b/sys/sys/sysctl.h
index 465bb84..086381f 100644
--- a/sys/sys/sysctl.h
+++ b/sys/sys/sysctl.h
@@ -601,9 +601,9 @@ int	sysctl_find_oid(int *name, u_int namelen, struct sysctl_oid **noid,
 #include <sys/cdefs.h>
 
 __BEGIN_DECLS
-int	sysctl __P((int *, u_int, void *, size_t *, void *, size_t));
-int	sysctlbyname __P((const char *, void *, size_t *, void *, size_t));
-int	sysctlnametomib __P((const char *, int *, size_t *));
+int	sysctl(int *, u_int, void *, size_t *, void *, size_t);
+int	sysctlbyname(const char *, void *, size_t *, void *, size_t);
+int	sysctlnametomib(const char *, int *, size_t *);
 __END_DECLS
 #endif	/* _KERNEL */
 
diff --git a/sys/sys/sysent.h b/sys/sys/sysent.h
index 6f74644..9d02ffa 100644
--- a/sys/sys/sysent.h
+++ b/sys/sys/sysent.h
@@ -38,7 +38,7 @@
 
 struct thread;
 
-typedef	int	sy_call_t __P((struct thread *, void *));
+typedef	int	sy_call_t(struct thread *, void *);
 
 struct sysent {		/* system call table */
 	int	sy_narg;	/* number of arguments */
@@ -64,22 +64,22 @@ struct sysentvec {
 	int		*sv_sigtbl;	/* signal translation table */
 	int		sv_errsize;	/* size of errno translation table */
 	int 		*sv_errtbl;	/* errno translation table */
-	int		(*sv_transtrap) __P((int, int));
+	int		(*sv_transtrap)(int, int);
 					/* translate trap-to-signal mapping */
-	int		(*sv_fixup) __P((register_t **, struct image_params *));
+	int		(*sv_fixup)(register_t **, struct image_params *);
 					/* stack fixup function */
-	void		(*sv_sendsig) __P((void (*)(int), int,
-					   struct __sigset *, u_long));
+	void		(*sv_sendsig)(void (*)(int), int,
+					   struct __sigset *, u_long);
 					/* send signal */
 	char 		*sv_sigcode;	/* start of sigtramp code */
 	int 		*sv_szsigcode;	/* size of sigtramp code */
-	void		(*sv_prepsyscall) __P((struct trapframe *, int *,
-					       u_int *, caddr_t *));
+	void		(*sv_prepsyscall)(struct trapframe *, int *,
+					       u_int *, caddr_t *);
 	char		*sv_name;	/* name of binary type */
-	int		(*sv_coredump) __P((struct thread *, struct vnode *,
-					    off_t));
+	int		(*sv_coredump)(struct thread *, struct vnode *,
+					    off_t);
 					/* function to dump core, or NULL */
-	int		(*sv_imgact_try) __P((struct image_params *));
+	int		(*sv_imgact_try)(struct image_params *);
 	int		sv_minsigstksz;	/* minimum signal stack size */
 };
 
@@ -123,10 +123,10 @@ SYSCALL_MODULE(syscallname,                             \
     & syscallname##_syscall, & syscallname##_sysent,    \
     NULL, NULL);
 
-int    syscall_register __P((int *offset, struct sysent *new_sysent,
-                             struct sysent *old_sysent));
-int    syscall_deregister __P((int *offset, struct sysent *old_sysent));
-int    syscall_module_handler __P((struct module *mod, int what, void *arg));
+int    syscall_register(int *offset, struct sysent *new_sysent,
+                             struct sysent *old_sysent);
+int    syscall_deregister(int *offset, struct sysent *old_sysent);
+int    syscall_module_handler(struct module *mod, int what, void *arg);
 
 #endif /* _KERNEL */
 
diff --git a/sys/sys/syslog.h b/sys/sys/syslog.h
index c14e024..80cac0a 100644
--- a/sys/sys/syslog.h
+++ b/sys/sys/syslog.h
@@ -192,11 +192,11 @@ CODE facilitynames[] = {
 #include <sys/cdefs.h>
 
 __BEGIN_DECLS
-void	closelog __P((void));
-void	openlog __P((const char *, int, int));
-int	setlogmask __P((int));
-void	syslog __P((int, const char *, ...)) __printflike(2, 3);
-void	vsyslog __P((int, const char *, _BSD_VA_LIST_)) __printflike(2, 0);
+void	closelog(void);
+void	openlog(const char *, int, int);
+int	setlogmask(int);
+void	syslog(int, const char *, ...) __printflike(2, 3);
+void	vsyslog(int, const char *, _BSD_VA_LIST_) __printflike(2, 0);
 __END_DECLS
 
 #endif /* !_KERNEL */
diff --git a/sys/sys/sysproto.h b/sys/sys/sysproto.h
index 2a4d2cb..83f3b27 100644
--- a/sys/sys/sysproto.h
+++ b/sys/sys/sysproto.h
@@ -1105,255 +1105,255 @@ struct thread_wakeup_args {
 struct kse_yield_args {
 	register_t dummy;
 };
-int	nosys __P((struct thread *, struct nosys_args *));
-void	sys_exit __P((struct thread *, struct sys_exit_args *));
-int	fork __P((struct thread *, struct fork_args *));
-int	read __P((struct thread *, struct read_args *));
-int	write __P((struct thread *, struct write_args *));
-int	open __P((struct thread *, struct open_args *));
-int	close __P((struct thread *, struct close_args *));
-int	wait4 __P((struct thread *, struct wait_args *));
-int	link __P((struct thread *, struct link_args *));
-int	unlink __P((struct thread *, struct unlink_args *));
-int	chdir __P((struct thread *, struct chdir_args *));
-int	fchdir __P((struct thread *, struct fchdir_args *));
-int	mknod __P((struct thread *, struct mknod_args *));
-int	chmod __P((struct thread *, struct chmod_args *));
-int	chown __P((struct thread *, struct chown_args *));
-int	obreak __P((struct thread *, struct obreak_args *));
-int	getfsstat __P((struct thread *, struct getfsstat_args *));
-int	getpid __P((struct thread *, struct getpid_args *));
-int	mount __P((struct thread *, struct mount_args *));
-int	unmount __P((struct thread *, struct unmount_args *));
-int	setuid __P((struct thread *, struct setuid_args *));
-int	getuid __P((struct thread *, struct getuid_args *));
-int	geteuid __P((struct thread *, struct geteuid_args *));
-int	ptrace __P((struct thread *, struct ptrace_args *));
-int	recvmsg __P((struct thread *, struct recvmsg_args *));
-int	sendmsg __P((struct thread *, struct sendmsg_args *));
-int	recvfrom __P((struct thread *, struct recvfrom_args *));
-int	accept __P((struct thread *, struct accept_args *));
-int	getpeername __P((struct thread *, struct getpeername_args *));
-int	getsockname __P((struct thread *, struct getsockname_args *));
-int	access __P((struct thread *, struct access_args *));
-int	chflags __P((struct thread *, struct chflags_args *));
-int	fchflags __P((struct thread *, struct fchflags_args *));
-int	sync __P((struct thread *, struct sync_args *));
-int	kill __P((struct thread *, struct kill_args *));
-int	getppid __P((struct thread *, struct getppid_args *));
-int	dup __P((struct thread *, struct dup_args *));
-int	pipe __P((struct thread *, struct pipe_args *));
-int	getegid __P((struct thread *, struct getegid_args *));
-int	profil __P((struct thread *, struct profil_args *));
-int	ktrace __P((struct thread *, struct ktrace_args *));
-int	getgid __P((struct thread *, struct getgid_args *));
-int	getlogin __P((struct thread *, struct getlogin_args *));
-int	setlogin __P((struct thread *, struct setlogin_args *));
-int	acct __P((struct thread *, struct acct_args *));
-int	sigaltstack __P((struct thread *, struct sigaltstack_args *));
-int	ioctl __P((struct thread *, struct ioctl_args *));
-int	reboot __P((struct thread *, struct reboot_args *));
-int	revoke __P((struct thread *, struct revoke_args *));
-int	symlink __P((struct thread *, struct symlink_args *));
-int	readlink __P((struct thread *, struct readlink_args *));
-int	execve __P((struct thread *, struct execve_args *));
-int	umask __P((struct thread *, struct umask_args *));
-int	chroot __P((struct thread *, struct chroot_args *));
-int	msync __P((struct thread *, struct msync_args *));
-int	vfork __P((struct thread *, struct vfork_args *));
-int	sbrk __P((struct thread *, struct sbrk_args *));
-int	sstk __P((struct thread *, struct sstk_args *));
-int	ovadvise __P((struct thread *, struct ovadvise_args *));
-int	munmap __P((struct thread *, struct munmap_args *));
-int	mprotect __P((struct thread *, struct mprotect_args *));
-int	madvise __P((struct thread *, struct madvise_args *));
-int	mincore __P((struct thread *, struct mincore_args *));
-int	getgroups __P((struct thread *, struct getgroups_args *));
-int	setgroups __P((struct thread *, struct setgroups_args *));
-int	getpgrp __P((struct thread *, struct getpgrp_args *));
-int	setpgid __P((struct thread *, struct setpgid_args *));
-int	setitimer __P((struct thread *, struct setitimer_args *));
-int	swapon __P((struct thread *, struct swapon_args *));
-int	getitimer __P((struct thread *, struct getitimer_args *));
-int	getdtablesize __P((struct thread *, struct getdtablesize_args *));
-int	dup2 __P((struct thread *, struct dup2_args *));
-int	fcntl __P((struct thread *, struct fcntl_args *));
-int	select __P((struct thread *, struct select_args *));
-int	fsync __P((struct thread *, struct fsync_args *));
-int	setpriority __P((struct thread *, struct setpriority_args *));
-int	socket __P((struct thread *, struct socket_args *));
-int	connect __P((struct thread *, struct connect_args *));
-int	getpriority __P((struct thread *, struct getpriority_args *));
-int	osigreturn __P((struct thread *, struct osigreturn_args *));
-int	bind __P((struct thread *, struct bind_args *));
-int	setsockopt __P((struct thread *, struct setsockopt_args *));
-int	listen __P((struct thread *, struct listen_args *));
-int	gettimeofday __P((struct thread *, struct gettimeofday_args *));
-int	getrusage __P((struct thread *, struct getrusage_args *));
-int	getsockopt __P((struct thread *, struct getsockopt_args *));
-int	readv __P((struct thread *, struct readv_args *));
-int	writev __P((struct thread *, struct writev_args *));
-int	settimeofday __P((struct thread *, struct settimeofday_args *));
-int	fchown __P((struct thread *, struct fchown_args *));
-int	fchmod __P((struct thread *, struct fchmod_args *));
-int	setreuid __P((struct thread *, struct setreuid_args *));
-int	setregid __P((struct thread *, struct setregid_args *));
-int	rename __P((struct thread *, struct rename_args *));
-int	flock __P((struct thread *, struct flock_args *));
-int	mkfifo __P((struct thread *, struct mkfifo_args *));
-int	sendto __P((struct thread *, struct sendto_args *));
-int	shutdown __P((struct thread *, struct shutdown_args *));
-int	socketpair __P((struct thread *, struct socketpair_args *));
-int	mkdir __P((struct thread *, struct mkdir_args *));
-int	rmdir __P((struct thread *, struct rmdir_args *));
-int	utimes __P((struct thread *, struct utimes_args *));
-int	adjtime __P((struct thread *, struct adjtime_args *));
-int	setsid __P((struct thread *, struct setsid_args *));
-int	quotactl __P((struct thread *, struct quotactl_args *));
-int	nfssvc __P((struct thread *, struct nfssvc_args *));
-int	statfs __P((struct thread *, struct statfs_args *));
-int	fstatfs __P((struct thread *, struct fstatfs_args *));
-int	getfh __P((struct thread *, struct getfh_args *));
-int	getdomainname __P((struct thread *, struct getdomainname_args *));
-int	setdomainname __P((struct thread *, struct setdomainname_args *));
-int	uname __P((struct thread *, struct uname_args *));
-int	sysarch __P((struct thread *, struct sysarch_args *));
-int	rtprio __P((struct thread *, struct rtprio_args *));
-int	semsys __P((struct thread *, struct semsys_args *));
-int	msgsys __P((struct thread *, struct msgsys_args *));
-int	shmsys __P((struct thread *, struct shmsys_args *));
-int	pread __P((struct thread *, struct pread_args *));
-int	pwrite __P((struct thread *, struct pwrite_args *));
-int	ntp_adjtime __P((struct thread *, struct ntp_adjtime_args *));
-int	setgid __P((struct thread *, struct setgid_args *));
-int	setegid __P((struct thread *, struct setegid_args *));
-int	seteuid __P((struct thread *, struct seteuid_args *));
-int	stat __P((struct thread *, struct stat_args *));
-int	fstat __P((struct thread *, struct fstat_args *));
-int	lstat __P((struct thread *, struct lstat_args *));
-int	pathconf __P((struct thread *, struct pathconf_args *));
-int	fpathconf __P((struct thread *, struct fpathconf_args *));
-int	getrlimit __P((struct thread *, struct __getrlimit_args *));
-int	setrlimit __P((struct thread *, struct __setrlimit_args *));
-int	getdirentries __P((struct thread *, struct getdirentries_args *));
-int	mmap __P((struct thread *, struct mmap_args *));
-int	lseek __P((struct thread *, struct lseek_args *));
-int	truncate __P((struct thread *, struct truncate_args *));
-int	ftruncate __P((struct thread *, struct ftruncate_args *));
-int	__sysctl __P((struct thread *, struct sysctl_args *));
-int	mlock __P((struct thread *, struct mlock_args *));
-int	munlock __P((struct thread *, struct munlock_args *));
-int	undelete __P((struct thread *, struct undelete_args *));
-int	futimes __P((struct thread *, struct futimes_args *));
-int	getpgid __P((struct thread *, struct getpgid_args *));
-int	poll __P((struct thread *, struct poll_args *));
-int	lkmnosys __P((struct thread *, struct nosys_args *));
-int	__semctl __P((struct thread *, struct __semctl_args *));
-int	semget __P((struct thread *, struct semget_args *));
-int	semop __P((struct thread *, struct semop_args *));
-int	msgctl __P((struct thread *, struct msgctl_args *));
-int	msgget __P((struct thread *, struct msgget_args *));
-int	msgsnd __P((struct thread *, struct msgsnd_args *));
-int	msgrcv __P((struct thread *, struct msgrcv_args *));
-int	shmat __P((struct thread *, struct shmat_args *));
-int	shmctl __P((struct thread *, struct shmctl_args *));
-int	shmdt __P((struct thread *, struct shmdt_args *));
-int	shmget __P((struct thread *, struct shmget_args *));
-int	clock_gettime __P((struct thread *, struct clock_gettime_args *));
-int	clock_settime __P((struct thread *, struct clock_settime_args *));
-int	clock_getres __P((struct thread *, struct clock_getres_args *));
-int	nanosleep __P((struct thread *, struct nanosleep_args *));
-int	minherit __P((struct thread *, struct minherit_args *));
-int	rfork __P((struct thread *, struct rfork_args *));
-int	openbsd_poll __P((struct thread *, struct openbsd_poll_args *));
-int	issetugid __P((struct thread *, struct issetugid_args *));
-int	lchown __P((struct thread *, struct lchown_args *));
-int	getdents __P((struct thread *, struct getdents_args *));
-int	lchmod __P((struct thread *, struct lchmod_args *));
-int	lutimes __P((struct thread *, struct lutimes_args *));
-int	nstat __P((struct thread *, struct nstat_args *));
-int	nfstat __P((struct thread *, struct nfstat_args *));
-int	nlstat __P((struct thread *, struct nlstat_args *));
-int	fhstatfs __P((struct thread *, struct fhstatfs_args *));
-int	fhopen __P((struct thread *, struct fhopen_args *));
-int	fhstat __P((struct thread *, struct fhstat_args *));
-int	modnext __P((struct thread *, struct modnext_args *));
-int	modstat __P((struct thread *, struct modstat_args *));
-int	modfnext __P((struct thread *, struct modfnext_args *));
-int	modfind __P((struct thread *, struct modfind_args *));
-int	kldload __P((struct thread *, struct kldload_args *));
-int	kldunload __P((struct thread *, struct kldunload_args *));
-int	kldfind __P((struct thread *, struct kldfind_args *));
-int	kldnext __P((struct thread *, struct kldnext_args *));
-int	kldstat __P((struct thread *, struct kldstat_args *));
-int	kldfirstmod __P((struct thread *, struct kldfirstmod_args *));
-int	getsid __P((struct thread *, struct getsid_args *));
-int	setresuid __P((struct thread *, struct setresuid_args *));
-int	setresgid __P((struct thread *, struct setresgid_args *));
-int	aio_return __P((struct thread *, struct aio_return_args *));
-int	aio_suspend __P((struct thread *, struct aio_suspend_args *));
-int	aio_cancel __P((struct thread *, struct aio_cancel_args *));
-int	aio_error __P((struct thread *, struct aio_error_args *));
-int	aio_read __P((struct thread *, struct aio_read_args *));
-int	aio_write __P((struct thread *, struct aio_write_args *));
-int	lio_listio __P((struct thread *, struct lio_listio_args *));
-int	yield __P((struct thread *, struct yield_args *));
-int	mlockall __P((struct thread *, struct mlockall_args *));
-int	munlockall __P((struct thread *, struct munlockall_args *));
-int	__getcwd __P((struct thread *, struct __getcwd_args *));
-int	sched_setparam __P((struct thread *, struct sched_setparam_args *));
-int	sched_getparam __P((struct thread *, struct sched_getparam_args *));
-int	sched_setscheduler __P((struct thread *, struct sched_setscheduler_args *));
-int	sched_getscheduler __P((struct thread *, struct sched_getscheduler_args *));
-int	sched_yield __P((struct thread *, struct sched_yield_args *));
-int	sched_get_priority_max __P((struct thread *, struct sched_get_priority_max_args *));
-int	sched_get_priority_min __P((struct thread *, struct sched_get_priority_min_args *));
-int	sched_rr_get_interval __P((struct thread *, struct sched_rr_get_interval_args *));
-int	utrace __P((struct thread *, struct utrace_args *));
-int	sendfile __P((struct thread *, struct sendfile_args *));
-int	kldsym __P((struct thread *, struct kldsym_args *));
-int	jail __P((struct thread *, struct jail_args *));
-int	sigprocmask __P((struct thread *, struct sigprocmask_args *));
-int	sigsuspend __P((struct thread *, struct sigsuspend_args *));
-int	sigaction __P((struct thread *, struct sigaction_args *));
-int	sigpending __P((struct thread *, struct sigpending_args *));
-int	sigreturn __P((struct thread *, struct sigreturn_args *));
-int	__acl_get_file __P((struct thread *, struct __acl_get_file_args *));
-int	__acl_set_file __P((struct thread *, struct __acl_set_file_args *));
-int	__acl_get_fd __P((struct thread *, struct __acl_get_fd_args *));
-int	__acl_set_fd __P((struct thread *, struct __acl_set_fd_args *));
-int	__acl_delete_file __P((struct thread *, struct __acl_delete_file_args *));
-int	__acl_delete_fd __P((struct thread *, struct __acl_delete_fd_args *));
-int	__acl_aclcheck_file __P((struct thread *, struct __acl_aclcheck_file_args *));
-int	__acl_aclcheck_fd __P((struct thread *, struct __acl_aclcheck_fd_args *));
-int	extattrctl __P((struct thread *, struct extattrctl_args *));
-int	extattr_set_file __P((struct thread *, struct extattr_set_file_args *));
-int	extattr_get_file __P((struct thread *, struct extattr_get_file_args *));
-int	extattr_delete_file __P((struct thread *, struct extattr_delete_file_args *));
-int	aio_waitcomplete __P((struct thread *, struct aio_waitcomplete_args *));
-int	getresuid __P((struct thread *, struct getresuid_args *));
-int	getresgid __P((struct thread *, struct getresgid_args *));
-int	kqueue __P((struct thread *, struct kqueue_args *));
-int	kevent __P((struct thread *, struct kevent_args *));
-int	__cap_get_proc __P((struct thread *, struct __cap_get_proc_args *));
-int	__cap_set_proc __P((struct thread *, struct __cap_set_proc_args *));
-int	__cap_get_fd __P((struct thread *, struct __cap_get_fd_args *));
-int	__cap_get_file __P((struct thread *, struct __cap_get_file_args *));
-int	__cap_set_fd __P((struct thread *, struct __cap_set_fd_args *));
-int	__cap_set_file __P((struct thread *, struct __cap_set_file_args *));
-int	lkmressys __P((struct thread *, struct nosys_args *));
-int	extattr_set_fd __P((struct thread *, struct extattr_set_fd_args *));
-int	extattr_get_fd __P((struct thread *, struct extattr_get_fd_args *));
-int	extattr_delete_fd __P((struct thread *, struct extattr_delete_fd_args *));
-int	__setugid __P((struct thread *, struct __setugid_args *));
-int	nfsclnt __P((struct thread *, struct nfsclnt_args *));
-int	eaccess __P((struct thread *, struct eaccess_args *));
-int	nmount __P((struct thread *, struct nmount_args *));
-int	kse_exit __P((struct thread *, struct kse_exit_args *));
-int	kse_wakeup __P((struct thread *, struct kse_wakeup_args *));
-int	kse_new __P((struct thread *, struct kse_new_args *));
-int	thread_wakeup __P((struct thread *, struct thread_wakeup_args *));
-int	kse_yield __P((struct thread *, struct kse_yield_args *));
+int	nosys(struct thread *, struct nosys_args *);
+void	sys_exit(struct thread *, struct sys_exit_args *);
+int	fork(struct thread *, struct fork_args *);
+int	read(struct thread *, struct read_args *);
+int	write(struct thread *, struct write_args *);
+int	open(struct thread *, struct open_args *);
+int	close(struct thread *, struct close_args *);
+int	wait4(struct thread *, struct wait_args *);
+int	link(struct thread *, struct link_args *);
+int	unlink(struct thread *, struct unlink_args *);
+int	chdir(struct thread *, struct chdir_args *);
+int	fchdir(struct thread *, struct fchdir_args *);
+int	mknod(struct thread *, struct mknod_args *);
+int	chmod(struct thread *, struct chmod_args *);
+int	chown(struct thread *, struct chown_args *);
+int	obreak(struct thread *, struct obreak_args *);
+int	getfsstat(struct thread *, struct getfsstat_args *);
+int	getpid(struct thread *, struct getpid_args *);
+int	mount(struct thread *, struct mount_args *);
+int	unmount(struct thread *, struct unmount_args *);
+int	setuid(struct thread *, struct setuid_args *);
+int	getuid(struct thread *, struct getuid_args *);
+int	geteuid(struct thread *, struct geteuid_args *);
+int	ptrace(struct thread *, struct ptrace_args *);
+int	recvmsg(struct thread *, struct recvmsg_args *);
+int	sendmsg(struct thread *, struct sendmsg_args *);
+int	recvfrom(struct thread *, struct recvfrom_args *);
+int	accept(struct thread *, struct accept_args *);
+int	getpeername(struct thread *, struct getpeername_args *);
+int	getsockname(struct thread *, struct getsockname_args *);
+int	access(struct thread *, struct access_args *);
+int	chflags(struct thread *, struct chflags_args *);
+int	fchflags(struct thread *, struct fchflags_args *);
+int	sync(struct thread *, struct sync_args *);
+int	kill(struct thread *, struct kill_args *);
+int	getppid(struct thread *, struct getppid_args *);
+int	dup(struct thread *, struct dup_args *);
+int	pipe(struct thread *, struct pipe_args *);
+int	getegid(struct thread *, struct getegid_args *);
+int	profil(struct thread *, struct profil_args *);
+int	ktrace(struct thread *, struct ktrace_args *);
+int	getgid(struct thread *, struct getgid_args *);
+int	getlogin(struct thread *, struct getlogin_args *);
+int	setlogin(struct thread *, struct setlogin_args *);
+int	acct(struct thread *, struct acct_args *);
+int	sigaltstack(struct thread *, struct sigaltstack_args *);
+int	ioctl(struct thread *, struct ioctl_args *);
+int	reboot(struct thread *, struct reboot_args *);
+int	revoke(struct thread *, struct revoke_args *);
+int	symlink(struct thread *, struct symlink_args *);
+int	readlink(struct thread *, struct readlink_args *);
+int	execve(struct thread *, struct execve_args *);
+int	umask(struct thread *, struct umask_args *);
+int	chroot(struct thread *, struct chroot_args *);
+int	msync(struct thread *, struct msync_args *);
+int	vfork(struct thread *, struct vfork_args *);
+int	sbrk(struct thread *, struct sbrk_args *);
+int	sstk(struct thread *, struct sstk_args *);
+int	ovadvise(struct thread *, struct ovadvise_args *);
+int	munmap(struct thread *, struct munmap_args *);
+int	mprotect(struct thread *, struct mprotect_args *);
+int	madvise(struct thread *, struct madvise_args *);
+int	mincore(struct thread *, struct mincore_args *);
+int	getgroups(struct thread *, struct getgroups_args *);
+int	setgroups(struct thread *, struct setgroups_args *);
+int	getpgrp(struct thread *, struct getpgrp_args *);
+int	setpgid(struct thread *, struct setpgid_args *);
+int	setitimer(struct thread *, struct setitimer_args *);
+int	swapon(struct thread *, struct swapon_args *);
+int	getitimer(struct thread *, struct getitimer_args *);
+int	getdtablesize(struct thread *, struct getdtablesize_args *);
+int	dup2(struct thread *, struct dup2_args *);
+int	fcntl(struct thread *, struct fcntl_args *);
+int	select(struct thread *, struct select_args *);
+int	fsync(struct thread *, struct fsync_args *);
+int	setpriority(struct thread *, struct setpriority_args *);
+int	socket(struct thread *, struct socket_args *);
+int	connect(struct thread *, struct connect_args *);
+int	getpriority(struct thread *, struct getpriority_args *);
+int	osigreturn(struct thread *, struct osigreturn_args *);
+int	bind(struct thread *, struct bind_args *);
+int	setsockopt(struct thread *, struct setsockopt_args *);
+int	listen(struct thread *, struct listen_args *);
+int	gettimeofday(struct thread *, struct gettimeofday_args *);
+int	getrusage(struct thread *, struct getrusage_args *);
+int	getsockopt(struct thread *, struct getsockopt_args *);
+int	readv(struct thread *, struct readv_args *);
+int	writev(struct thread *, struct writev_args *);
+int	settimeofday(struct thread *, struct settimeofday_args *);
+int	fchown(struct thread *, struct fchown_args *);
+int	fchmod(struct thread *, struct fchmod_args *);
+int	setreuid(struct thread *, struct setreuid_args *);
+int	setregid(struct thread *, struct setregid_args *);
+int	rename(struct thread *, struct rename_args *);
+int	flock(struct thread *, struct flock_args *);
+int	mkfifo(struct thread *, struct mkfifo_args *);
+int	sendto(struct thread *, struct sendto_args *);
+int	shutdown(struct thread *, struct shutdown_args *);
+int	socketpair(struct thread *, struct socketpair_args *);
+int	mkdir(struct thread *, struct mkdir_args *);
+int	rmdir(struct thread *, struct rmdir_args *);
+int	utimes(struct thread *, struct utimes_args *);
+int	adjtime(struct thread *, struct adjtime_args *);
+int	setsid(struct thread *, struct setsid_args *);
+int	quotactl(struct thread *, struct quotactl_args *);
+int	nfssvc(struct thread *, struct nfssvc_args *);
+int	statfs(struct thread *, struct statfs_args *);
+int	fstatfs(struct thread *, struct fstatfs_args *);
+int	getfh(struct thread *, struct getfh_args *);
+int	getdomainname(struct thread *, struct getdomainname_args *);
+int	setdomainname(struct thread *, struct setdomainname_args *);
+int	uname(struct thread *, struct uname_args *);
+int	sysarch(struct thread *, struct sysarch_args *);
+int	rtprio(struct thread *, struct rtprio_args *);
+int	semsys(struct thread *, struct semsys_args *);
+int	msgsys(struct thread *, struct msgsys_args *);
+int	shmsys(struct thread *, struct shmsys_args *);
+int	pread(struct thread *, struct pread_args *);
+int	pwrite(struct thread *, struct pwrite_args *);
+int	ntp_adjtime(struct thread *, struct ntp_adjtime_args *);
+int	setgid(struct thread *, struct setgid_args *);
+int	setegid(struct thread *, struct setegid_args *);
+int	seteuid(struct thread *, struct seteuid_args *);
+int	stat(struct thread *, struct stat_args *);
+int	fstat(struct thread *, struct fstat_args *);
+int	lstat(struct thread *, struct lstat_args *);
+int	pathconf(struct thread *, struct pathconf_args *);
+int	fpathconf(struct thread *, struct fpathconf_args *);
+int	getrlimit(struct thread *, struct __getrlimit_args *);
+int	setrlimit(struct thread *, struct __setrlimit_args *);
+int	getdirentries(struct thread *, struct getdirentries_args *);
+int	mmap(struct thread *, struct mmap_args *);
+int	lseek(struct thread *, struct lseek_args *);
+int	truncate(struct thread *, struct truncate_args *);
+int	ftruncate(struct thread *, struct ftruncate_args *);
+int	__sysctl(struct thread *, struct sysctl_args *);
+int	mlock(struct thread *, struct mlock_args *);
+int	munlock(struct thread *, struct munlock_args *);
+int	undelete(struct thread *, struct undelete_args *);
+int	futimes(struct thread *, struct futimes_args *);
+int	getpgid(struct thread *, struct getpgid_args *);
+int	poll(struct thread *, struct poll_args *);
+int	lkmnosys(struct thread *, struct nosys_args *);
+int	__semctl(struct thread *, struct __semctl_args *);
+int	semget(struct thread *, struct semget_args *);
+int	semop(struct thread *, struct semop_args *);
+int	msgctl(struct thread *, struct msgctl_args *);
+int	msgget(struct thread *, struct msgget_args *);
+int	msgsnd(struct thread *, struct msgsnd_args *);
+int	msgrcv(struct thread *, struct msgrcv_args *);
+int	shmat(struct thread *, struct shmat_args *);
+int	shmctl(struct thread *, struct shmctl_args *);
+int	shmdt(struct thread *, struct shmdt_args *);
+int	shmget(struct thread *, struct shmget_args *);
+int	clock_gettime(struct thread *, struct clock_gettime_args *);
+int	clock_settime(struct thread *, struct clock_settime_args *);
+int	clock_getres(struct thread *, struct clock_getres_args *);
+int	nanosleep(struct thread *, struct nanosleep_args *);
+int	minherit(struct thread *, struct minherit_args *);
+int	rfork(struct thread *, struct rfork_args *);
+int	openbsd_poll(struct thread *, struct openbsd_poll_args *);
+int	issetugid(struct thread *, struct issetugid_args *);
+int	lchown(struct thread *, struct lchown_args *);
+int	getdents(struct thread *, struct getdents_args *);
+int	lchmod(struct thread *, struct lchmod_args *);
+int	lutimes(struct thread *, struct lutimes_args *);
+int	nstat(struct thread *, struct nstat_args *);
+int	nfstat(struct thread *, struct nfstat_args *);
+int	nlstat(struct thread *, struct nlstat_args *);
+int	fhstatfs(struct thread *, struct fhstatfs_args *);
+int	fhopen(struct thread *, struct fhopen_args *);
+int	fhstat(struct thread *, struct fhstat_args *);
+int	modnext(struct thread *, struct modnext_args *);
+int	modstat(struct thread *, struct modstat_args *);
+int	modfnext(struct thread *, struct modfnext_args *);
+int	modfind(struct thread *, struct modfind_args *);
+int	kldload(struct thread *, struct kldload_args *);
+int	kldunload(struct thread *, struct kldunload_args *);
+int	kldfind(struct thread *, struct kldfind_args *);
+int	kldnext(struct thread *, struct kldnext_args *);
+int	kldstat(struct thread *, struct kldstat_args *);
+int	kldfirstmod(struct thread *, struct kldfirstmod_args *);
+int	getsid(struct thread *, struct getsid_args *);
+int	setresuid(struct thread *, struct setresuid_args *);
+int	setresgid(struct thread *, struct setresgid_args *);
+int	aio_return(struct thread *, struct aio_return_args *);
+int	aio_suspend(struct thread *, struct aio_suspend_args *);
+int	aio_cancel(struct thread *, struct aio_cancel_args *);
+int	aio_error(struct thread *, struct aio_error_args *);
+int	aio_read(struct thread *, struct aio_read_args *);
+int	aio_write(struct thread *, struct aio_write_args *);
+int	lio_listio(struct thread *, struct lio_listio_args *);
+int	yield(struct thread *, struct yield_args *);
+int	mlockall(struct thread *, struct mlockall_args *);
+int	munlockall(struct thread *, struct munlockall_args *);
+int	__getcwd(struct thread *, struct __getcwd_args *);
+int	sched_setparam(struct thread *, struct sched_setparam_args *);
+int	sched_getparam(struct thread *, struct sched_getparam_args *);
+int	sched_setscheduler(struct thread *, struct sched_setscheduler_args *);
+int	sched_getscheduler(struct thread *, struct sched_getscheduler_args *);
+int	sched_yield(struct thread *, struct sched_yield_args *);
+int	sched_get_priority_max(struct thread *, struct sched_get_priority_max_args *);
+int	sched_get_priority_min(struct thread *, struct sched_get_priority_min_args *);
+int	sched_rr_get_interval(struct thread *, struct sched_rr_get_interval_args *);
+int	utrace(struct thread *, struct utrace_args *);
+int	sendfile(struct thread *, struct sendfile_args *);
+int	kldsym(struct thread *, struct kldsym_args *);
+int	jail(struct thread *, struct jail_args *);
+int	sigprocmask(struct thread *, struct sigprocmask_args *);
+int	sigsuspend(struct thread *, struct sigsuspend_args *);
+int	sigaction(struct thread *, struct sigaction_args *);
+int	sigpending(struct thread *, struct sigpending_args *);
+int	sigreturn(struct thread *, struct sigreturn_args *);
+int	__acl_get_file(struct thread *, struct __acl_get_file_args *);
+int	__acl_set_file(struct thread *, struct __acl_set_file_args *);
+int	__acl_get_fd(struct thread *, struct __acl_get_fd_args *);
+int	__acl_set_fd(struct thread *, struct __acl_set_fd_args *);
+int	__acl_delete_file(struct thread *, struct __acl_delete_file_args *);
+int	__acl_delete_fd(struct thread *, struct __acl_delete_fd_args *);
+int	__acl_aclcheck_file(struct thread *, struct __acl_aclcheck_file_args *);
+int	__acl_aclcheck_fd(struct thread *, struct __acl_aclcheck_fd_args *);
+int	extattrctl(struct thread *, struct extattrctl_args *);
+int	extattr_set_file(struct thread *, struct extattr_set_file_args *);
+int	extattr_get_file(struct thread *, struct extattr_get_file_args *);
+int	extattr_delete_file(struct thread *, struct extattr_delete_file_args *);
+int	aio_waitcomplete(struct thread *, struct aio_waitcomplete_args *);
+int	getresuid(struct thread *, struct getresuid_args *);
+int	getresgid(struct thread *, struct getresgid_args *);
+int	kqueue(struct thread *, struct kqueue_args *);
+int	kevent(struct thread *, struct kevent_args *);
+int	__cap_get_proc(struct thread *, struct __cap_get_proc_args *);
+int	__cap_set_proc(struct thread *, struct __cap_set_proc_args *);
+int	__cap_get_fd(struct thread *, struct __cap_get_fd_args *);
+int	__cap_get_file(struct thread *, struct __cap_get_file_args *);
+int	__cap_set_fd(struct thread *, struct __cap_set_fd_args *);
+int	__cap_set_file(struct thread *, struct __cap_set_file_args *);
+int	lkmressys(struct thread *, struct nosys_args *);
+int	extattr_set_fd(struct thread *, struct extattr_set_fd_args *);
+int	extattr_get_fd(struct thread *, struct extattr_get_fd_args *);
+int	extattr_delete_fd(struct thread *, struct extattr_delete_fd_args *);
+int	__setugid(struct thread *, struct __setugid_args *);
+int	nfsclnt(struct thread *, struct nfsclnt_args *);
+int	eaccess(struct thread *, struct eaccess_args *);
+int	nmount(struct thread *, struct nmount_args *);
+int	kse_exit(struct thread *, struct kse_exit_args *);
+int	kse_wakeup(struct thread *, struct kse_wakeup_args *);
+int	kse_new(struct thread *, struct kse_new_args *);
+int	thread_wakeup(struct thread *, struct thread_wakeup_args *);
+int	kse_yield(struct thread *, struct kse_yield_args *);
 
 #ifdef COMPAT_43
 
@@ -1483,42 +1483,42 @@ struct ogetdirentries_args {
 	char count_l_[PADL_(u_int)]; u_int count; char count_r_[PADR_(u_int)];
 	char basep_l_[PADL_(long *)]; long * basep; char basep_r_[PADR_(long *)];
 };
-int	ocreat __P((struct thread *, struct ocreat_args *));
-int	olseek __P((struct thread *, struct olseek_args *));
-int	ostat __P((struct thread *, struct ostat_args *));
-int	olstat __P((struct thread *, struct olstat_args *));
-int	osigaction __P((struct thread *, struct osigaction_args *));
-int	osigprocmask __P((struct thread *, struct osigprocmask_args *));
-int	osigpending __P((struct thread *, struct osigpending_args *));
-int	ofstat __P((struct thread *, struct ofstat_args *));
-int	ogetkerninfo __P((struct thread *, struct getkerninfo_args *));
-int	ogetpagesize __P((struct thread *, struct getpagesize_args *));
-int	ommap __P((struct thread *, struct ommap_args *));
-int	owait __P((struct thread *, struct owait_args *));
-int	ogethostname __P((struct thread *, struct gethostname_args *));
-int	osethostname __P((struct thread *, struct sethostname_args *));
-int	oaccept __P((struct thread *, struct accept_args *));
-int	osend __P((struct thread *, struct osend_args *));
-int	orecv __P((struct thread *, struct orecv_args *));
-int	osigvec __P((struct thread *, struct osigvec_args *));
-int	osigblock __P((struct thread *, struct osigblock_args *));
-int	osigsetmask __P((struct thread *, struct osigsetmask_args *));
-int	osigsuspend __P((struct thread *, struct osigsuspend_args *));
-int	osigstack __P((struct thread *, struct osigstack_args *));
-int	orecvmsg __P((struct thread *, struct orecvmsg_args *));
-int	osendmsg __P((struct thread *, struct osendmsg_args *));
-int	orecvfrom __P((struct thread *, struct recvfrom_args *));
-int	otruncate __P((struct thread *, struct otruncate_args *));
-int	oftruncate __P((struct thread *, struct oftruncate_args *));
-int	ogetpeername __P((struct thread *, struct ogetpeername_args *));
-int	ogethostid __P((struct thread *, struct ogethostid_args *));
-int	osethostid __P((struct thread *, struct osethostid_args *));
-int	ogetrlimit __P((struct thread *, struct ogetrlimit_args *));
-int	osetrlimit __P((struct thread *, struct osetrlimit_args *));
-int	okillpg __P((struct thread *, struct okillpg_args *));
-int	oquota __P((struct thread *, struct oquota_args *));
-int	ogetsockname __P((struct thread *, struct getsockname_args *));
-int	ogetdirentries __P((struct thread *, struct ogetdirentries_args *));
+int	ocreat(struct thread *, struct ocreat_args *);
+int	olseek(struct thread *, struct olseek_args *);
+int	ostat(struct thread *, struct ostat_args *);
+int	olstat(struct thread *, struct olstat_args *);
+int	osigaction(struct thread *, struct osigaction_args *);
+int	osigprocmask(struct thread *, struct osigprocmask_args *);
+int	osigpending(struct thread *, struct osigpending_args *);
+int	ofstat(struct thread *, struct ofstat_args *);
+int	ogetkerninfo(struct thread *, struct getkerninfo_args *);
+int	ogetpagesize(struct thread *, struct getpagesize_args *);
+int	ommap(struct thread *, struct ommap_args *);
+int	owait(struct thread *, struct owait_args *);
+int	ogethostname(struct thread *, struct gethostname_args *);
+int	osethostname(struct thread *, struct sethostname_args *);
+int	oaccept(struct thread *, struct accept_args *);
+int	osend(struct thread *, struct osend_args *);
+int	orecv(struct thread *, struct orecv_args *);
+int	osigvec(struct thread *, struct osigvec_args *);
+int	osigblock(struct thread *, struct osigblock_args *);
+int	osigsetmask(struct thread *, struct osigsetmask_args *);
+int	osigsuspend(struct thread *, struct osigsuspend_args *);
+int	osigstack(struct thread *, struct osigstack_args *);
+int	orecvmsg(struct thread *, struct orecvmsg_args *);
+int	osendmsg(struct thread *, struct osendmsg_args *);
+int	orecvfrom(struct thread *, struct recvfrom_args *);
+int	otruncate(struct thread *, struct otruncate_args *);
+int	oftruncate(struct thread *, struct oftruncate_args *);
+int	ogetpeername(struct thread *, struct ogetpeername_args *);
+int	ogethostid(struct thread *, struct ogethostid_args *);
+int	osethostid(struct thread *, struct osethostid_args *);
+int	ogetrlimit(struct thread *, struct ogetrlimit_args *);
+int	osetrlimit(struct thread *, struct osetrlimit_args *);
+int	okillpg(struct thread *, struct okillpg_args *);
+int	oquota(struct thread *, struct oquota_args *);
+int	ogetsockname(struct thread *, struct getsockname_args *);
+int	ogetdirentries(struct thread *, struct ogetdirentries_args *);
 
 #endif /* COMPAT_43 */
 
diff --git a/sys/sys/systm.h b/sys/sys/systm.h
index 37eb4bf..cf03dba 100644
--- a/sys/sys/systm.h
+++ b/sys/sys/systm.h
@@ -109,134 +109,134 @@ struct ucred;
 struct uio;
 struct _jmp_buf;
 
-int	setjmp __P((struct _jmp_buf *));
-void	longjmp __P((struct _jmp_buf *, int)) __dead2;
-void	Debugger __P((const char *msg));
-int	dumpstatus __P((vm_offset_t addr, off_t count));
-int	nullop __P((void));
-int	eopnotsupp __P((void));
-int	seltrue __P((dev_t dev, int which, struct thread *td));
-int	ureadc __P((int, struct uio *));
-void	*hashinit __P((int count, struct malloc_type *type, u_long *hashmask));
-void	*phashinit __P((int count, struct malloc_type *type, u_long *nentries));
+int	setjmp(struct _jmp_buf *);
+void	longjmp(struct _jmp_buf *, int) __dead2;
+void	Debugger(const char *msg);
+int	dumpstatus(vm_offset_t addr, off_t count);
+int	nullop(void);
+int	eopnotsupp(void);
+int	seltrue(dev_t dev, int which, struct thread *td);
+int	ureadc(int, struct uio *);
+void	*hashinit(int count, struct malloc_type *type, u_long *hashmask);
+void	*phashinit(int count, struct malloc_type *type, u_long *nentries);
 
 #ifdef RESTARTABLE_PANICS
-void	panic __P((const char *, ...)) __printflike(1, 2);
+void	panic(const char *, ...) __printflike(1, 2);
 #else
-void	panic __P((const char *, ...)) __dead2 __printflike(1, 2);
+void	panic(const char *, ...) __dead2 __printflike(1, 2);
 #endif
 
-void	cpu_boot __P((int));
-void	cpu_rootconf __P((void));
-void	critical_enter __P((void));
-void	critical_exit __P((void));
-void	init_param1 __P((void));
-void	init_param2 __P((int physpages));
-void	tablefull __P((const char *));
-int	kvprintf __P((char const *, void (*)(int, void*), void *, int,
-		      _BSD_VA_LIST_)) __printflike(1, 0);
-void	log __P((int, const char *, ...)) __printflike(2, 3);
-void	log_console __P((struct uio *));
-int	printf __P((const char *, ...)) __printflike(1, 2);
-int	snprintf __P((char *, size_t, const char *, ...)) __printflike(3, 4);
-int	sprintf __P((char *buf, const char *, ...)) __printflike(2, 3);
-int	uprintf __P((const char *, ...)) __printflike(1, 2);
-int	vprintf __P((const char *, _BSD_VA_LIST_)) __printflike(1, 0);
-int	vsnprintf __P((char *, size_t, const char *, _BSD_VA_LIST_)) __printflike(3, 0);
-int     vsprintf __P((char *buf, const char *, _BSD_VA_LIST_)) __printflike(2, 0);
-int	ttyprintf __P((struct tty *, const char *, ...)) __printflike(2, 3);
-int	sscanf __P((const char *, char const *, ...));
-int	vsscanf __P((const char *, char const *, _BSD_VA_LIST_));
-long	strtol __P((const char *, char **, int));
-u_long	strtoul __P((const char *, char **, int));
-quad_t	strtoq __P((const char *, char **, int));
-u_quad_t strtouq __P((const char *, char **, int));
-void	tprintf __P((struct proc *p, int pri, const char *, ...)) __printflike(3, 4);
-
-void	bcopy __P((const void *from, void *to, size_t len));
-void	ovbcopy __P((const void *from, void *to, size_t len));
+void	cpu_boot(int);
+void	cpu_rootconf(void);
+void	critical_enter(void);
+void	critical_exit(void);
+void	init_param1(void);
+void	init_param2(int physpages);
+void	tablefull(const char *);
+int	kvprintf(char const *, void (*)(int, void*), void *, int,
+		      _BSD_VA_LIST_) __printflike(1, 0);
+void	log(int, const char *, ...) __printflike(2, 3);
+void	log_console(struct uio *);
+int	printf(const char *, ...) __printflike(1, 2);
+int	snprintf(char *, size_t, const char *, ...) __printflike(3, 4);
+int	sprintf(char *buf, const char *, ...) __printflike(2, 3);
+int	uprintf(const char *, ...) __printflike(1, 2);
+int	vprintf(const char *, _BSD_VA_LIST_) __printflike(1, 0);
+int	vsnprintf(char *, size_t, const char *, _BSD_VA_LIST_) __printflike(3, 0);
+int     vsprintf(char *buf, const char *, _BSD_VA_LIST_) __printflike(2, 0);
+int	ttyprintf(struct tty *, const char *, ...) __printflike(2, 3);
+int	sscanf(const char *, char const *, ...);
+int	vsscanf(const char *, char const *, _BSD_VA_LIST_);
+long	strtol(const char *, char **, int);
+u_long	strtoul(const char *, char **, int);
+quad_t	strtoq(const char *, char **, int);
+u_quad_t strtouq(const char *, char **, int);
+void	tprintf(struct proc *p, int pri, const char *, ...) __printflike(3, 4);
+
+void	bcopy(const void *from, void *to, size_t len);
+void	ovbcopy(const void *from, void *to, size_t len);
 
 #ifdef __i386__
-extern void	(*bzero) __P((void *buf, size_t len));
+extern void	(*bzero)(void *buf, size_t len);
 #else
-void	bzero __P((void *buf, size_t len));
+void	bzero(void *buf, size_t len);
 #endif
 
-void	*memcpy __P((void *to, const void *from, size_t len));
+void	*memcpy(void *to, const void *from, size_t len);
 
-int	copystr __P((const void *kfaddr, void *kdaddr, size_t len,
-		size_t *lencopied));
-int	copyinstr __P((const void *udaddr, void *kaddr, size_t len,
-		size_t *lencopied));
-int	copyin __P((const void *udaddr, void *kaddr, size_t len));
-int	copyout __P((const void *kaddr, void *udaddr, size_t len));
+int	copystr(const void *kfaddr, void *kdaddr, size_t len,
+		size_t *lencopied);
+int	copyinstr(const void *udaddr, void *kaddr, size_t len,
+		size_t *lencopied);
+int	copyin(const void *udaddr, void *kaddr, size_t len);
+int	copyout(const void *kaddr, void *udaddr, size_t len);
 
-int	fubyte __P((const void *base));
-int	subyte __P((void *base, int byte));
-int	suibyte __P((void *base, int byte));
-long	fuword __P((const void *base));
-int	suword __P((void *base, long word));
-int	fusword __P((void *base));
-int	susword __P((void *base, int word));
+int	fubyte(const void *base);
+int	subyte(void *base, int byte);
+int	suibyte(void *base, int byte);
+long	fuword(const void *base);
+int	suword(void *base, long word);
+int	fusword(void *base);
+int	susword(void *base, int word);
 
-void	realitexpire __P((void *));
+void	realitexpire(void *);
 
-void	hardclock __P((struct clockframe *frame));
-void	hardclock_process __P((struct thread *td, int user));
-void	softclock __P((void *));
-void	statclock __P((struct clockframe *frame));
-void	statclock_process __P((struct kse *ke, register_t pc, int user));
+void	hardclock(struct clockframe *frame);
+void	hardclock_process(struct thread *td, int user);
+void	softclock(void *);
+void	statclock(struct clockframe *frame);
+void	statclock_process(struct kse *ke, register_t pc, int user);
 
-void	startprofclock __P((struct proc *));
-void	stopprofclock __P((struct proc *));
-void	setstatclockrate __P((int hzrate));
+void	startprofclock(struct proc *);
+void	stopprofclock(struct proc *);
+void	setstatclockrate(int hzrate);
 
 /* flags for suser_xxx() */
 #define PRISON_ROOT	1
 
-int	suser __P((struct proc *));
-int	suser_td __P((struct thread *));
-int	suser_xxx __P((struct ucred *cred, struct proc *proc, int flag));
-int	suser_xxx_td __P((struct ucred *cred, struct thread *thread, int flag));
-int	cr_cansee __P((struct ucred *u1, struct ucred *u2));
+int	suser(struct proc *);
+int	suser_td(struct thread *);
+int	suser_xxx(struct ucred *cred, struct proc *proc, int flag);
+int	suser_xxx_td(struct ucred *cred, struct thread *thread, int flag);
+int	cr_cansee(struct ucred *u1, struct ucred *u2);
 
-char	*getenv __P((const char *name));
-int	getenv_int __P((const char *name, int *data));
-int	getenv_string __P((const char *name, char *data, int size));
-int	getenv_quad __P((const char *name, quad_t *data));
+char	*getenv(const char *name);
+int	getenv_int(const char *name, int *data);
+int	getenv_string(const char *name, char *data, int size);
+int	getenv_quad(const char *name, quad_t *data);
 
 #ifdef APM_FIXUP_CALLTODO 
 struct timeval;
-void	adjust_timeout_calltodo __P((struct timeval *time_change)); 
+void	adjust_timeout_calltodo(struct timeval *time_change); 
 #endif /* APM_FIXUP_CALLTODO */ 
 
 #include <sys/libkern.h>
 
 /* Initialize the world */
-void	consinit __P((void));
-void	cpu_initclocks __P((void));
-void	usrinfoinit __P((void));
+void	consinit(void);
+void	cpu_initclocks(void);
+void	usrinfoinit(void);
 
 /* Finalize the world. */
-void	shutdown_nice __P((int));
+void	shutdown_nice(int);
 
 /*
  * Kernel to clock driver interface.
  */
-void	inittodr __P((time_t base));
-void	resettodr __P((void));
-void	startrtclock __P((void));
+void	inittodr(time_t base);
+void	resettodr(void);
+void	startrtclock(void);
 
 /* Timeouts */
-typedef void timeout_t __P((void *));	/* timeout function type */
+typedef void timeout_t(void *);	/* timeout function type */
 #define CALLOUT_HANDLE_INITIALIZER(handle)	\
 	{ NULL }
 
-void	callout_handle_init __P((struct callout_handle *));
-struct	callout_handle timeout __P((timeout_t *, void *, int));
-void	untimeout __P((timeout_t *, void *, struct callout_handle));
-caddr_t	kern_timeout_callwheel_alloc __P((caddr_t v));
-void	kern_timeout_callwheel_init __P((void));
+void	callout_handle_init(struct callout_handle *);
+struct	callout_handle timeout(timeout_t *, void *, int);
+void	untimeout(timeout_t *, void *, struct callout_handle);
+caddr_t	kern_timeout_callwheel_alloc(caddr_t v);
+void	kern_timeout_callwheel_init(void);
 
 /* Stubs for obsolete functions that used to be for interrupt  management */
 static __inline void		spl0(void)		{ return; }
@@ -261,23 +261,23 @@ static __inline void		splx(intrmask_t ipl)	{ return; }
  */
 
 /* Exit callout list declarations. */
-typedef void (*exitlist_fn) __P((struct proc *procp));
+typedef void (*exitlist_fn)(struct proc *procp);
 
-int	at_exit __P((exitlist_fn function));
-int	rm_at_exit __P((exitlist_fn function));
+int	at_exit(exitlist_fn function);
+int	rm_at_exit(exitlist_fn function);
 
 /* Fork callout list declarations. */
-typedef void (*forklist_fn) __P((struct proc *parent, struct proc *child,
-				 int flags));
+typedef void (*forklist_fn)(struct proc *parent, struct proc *child,
+				 int flags);
 
-int	at_fork __P((forklist_fn function));
-int	rm_at_fork __P((forklist_fn function));
+int	at_fork(forklist_fn function);
+int	rm_at_fork(forklist_fn function);
 
 /* Exec callout list declarations. */
-typedef void (*execlist_fn) __P((struct proc *procp));
+typedef void (*execlist_fn)(struct proc *procp);
 
-int	at_exec __P((execlist_fn function));
-int	rm_at_exec __P((execlist_fn function));
+int	at_exec(execlist_fn function);
+int	rm_at_exec(execlist_fn function);
 
 /*
  * Not exactly a callout LIST, but a callout entry.
@@ -286,7 +286,7 @@ int	rm_at_exec __P((execlist_fn function));
  * kernel needs to be able to hold off the watchdog, when the process
  * is not active, e.g., when dumping core.
  */
-typedef void (*watchdog_tickle_fn) __P((void));
+typedef void (*watchdog_tickle_fn)(void);
 
 extern watchdog_tickle_fn	wdog_tickler;
 
@@ -294,11 +294,11 @@ extern watchdog_tickle_fn	wdog_tickler;
  * Common `proc' functions are declared here so that proc.h can be included
  * less often.
  */
-int	msleep __P((void *chan, struct mtx *mtx, int pri, const char *wmesg,
-		    int timo));
+int	msleep(void *chan, struct mtx *mtx, int pri, const char *wmesg,
+		    int timo);
 #define	tsleep(chan, pri, wmesg, timo)	msleep(chan, NULL, pri, wmesg, timo)
-void	wakeup __P((void *chan));
-void	wakeup_one __P((void *chan));
+void	wakeup(void *chan);
+void	wakeup_one(void *chan);
 
 /*
  * Common `dev_t' stuff are declared here to avoid #include poisoning
@@ -314,6 +314,6 @@ int umajor(udev_t dev);
 udev_t makeudev(int x, int y);
 
 /* XXX: Should be void nanodelay(u_int nsec); */
-void	DELAY __P((int usec));
+void	DELAY(int usec);
 
 #endif /* !_SYS_SYSTM_H_ */
diff --git a/sys/sys/termios.h b/sys/sys/termios.h
index d12484b..9a96589 100644
--- a/sys/sys/termios.h
+++ b/sys/sys/termios.h
@@ -249,20 +249,20 @@ struct termios {
 #include <sys/cdefs.h>
 
 __BEGIN_DECLS
-speed_t	cfgetispeed __P((const struct termios *));
-speed_t	cfgetospeed __P((const struct termios *));
-int	cfsetispeed __P((struct termios *, speed_t));
-int	cfsetospeed __P((struct termios *, speed_t));
-int	tcgetattr __P((int, struct termios *));
-int	tcsetattr __P((int, int, const struct termios *));
-int	tcdrain __P((int));
-int	tcflow __P((int, int));
-int	tcflush __P((int, int));
-int	tcsendbreak __P((int, int));
+speed_t	cfgetispeed(const struct termios *);
+speed_t	cfgetospeed(const struct termios *);
+int	cfsetispeed(struct termios *, speed_t);
+int	cfsetospeed(struct termios *, speed_t);
+int	tcgetattr(int, struct termios *);
+int	tcsetattr(int, int, const struct termios *);
+int	tcdrain(int);
+int	tcflow(int, int);
+int	tcflush(int, int);
+int	tcsendbreak(int, int);
 
 #ifndef _POSIX_SOURCE
-void	cfmakeraw __P((struct termios *));
-int	cfsetspeed __P((struct termios *, speed_t));
+void	cfmakeraw(struct termios *);
+int	cfsetspeed(struct termios *, speed_t);
 #endif /* !_POSIX_SOURCE */
 __END_DECLS
 
diff --git a/sys/sys/time.h b/sys/sys/time.h
index 7347ffc..1d734a3 100644
--- a/sys/sys/time.h
+++ b/sys/sys/time.h
@@ -266,33 +266,33 @@ extern time_t	time_second;
 
 void	binuptime(struct bintime *bt);
 void	bintime(struct bintime *bt);
-void	getmicrouptime __P((struct timeval *tv));
-void	getmicrotime __P((struct timeval *tv));
-void	getnanouptime __P((struct timespec *tsp));
-void	getnanotime __P((struct timespec *tsp));
-int	itimerdecr __P((struct itimerval *itp, int usec));
-int	itimerfix __P((struct timeval *tv));
-void	microuptime __P((struct timeval *tv));
-void	microtime __P((struct timeval *tv));
-void	nanouptime __P((struct timespec *ts));
-void	nanotime __P((struct timespec *ts));
-void	timevaladd __P((struct timeval *, struct timeval *));
-void	timevalsub __P((struct timeval *, struct timeval *));
-int	tvtohz __P((struct timeval *));
+void	getmicrouptime(struct timeval *tv);
+void	getmicrotime(struct timeval *tv);
+void	getnanouptime(struct timespec *tsp);
+void	getnanotime(struct timespec *tsp);
+int	itimerdecr(struct itimerval *itp, int usec);
+int	itimerfix(struct timeval *tv);
+void	microuptime(struct timeval *tv);
+void	microtime(struct timeval *tv);
+void	nanouptime(struct timespec *ts);
+void	nanotime(struct timespec *ts);
+void	timevaladd(struct timeval *, struct timeval *);
+void	timevalsub(struct timeval *, struct timeval *);
+int	tvtohz(struct timeval *);
 #else /* !_KERNEL */
 #include <time.h>
 
 #include <sys/cdefs.h>
 
 __BEGIN_DECLS
-int	adjtime __P((const struct timeval *, struct timeval *));
-int	futimes __P((int, const struct timeval *));
-int	getitimer __P((int, struct itimerval *));
-int	gettimeofday __P((struct timeval *, struct timezone *));
-int	lutimes __P((const char *, const struct timeval *));
-int	setitimer __P((int, const struct itimerval *, struct itimerval *));
-int	settimeofday __P((const struct timeval *, const struct timezone *));
-int	utimes __P((const char *, const struct timeval *));
+int	adjtime(const struct timeval *, struct timeval *);
+int	futimes(int, const struct timeval *);
+int	getitimer(int, struct itimerval *);
+int	gettimeofday(struct timeval *, struct timezone *);
+int	lutimes(const char *, const struct timeval *);
+int	setitimer(int, const struct itimerval *, struct itimerval *);
+int	settimeofday(const struct timeval *, const struct timezone *);
+int	utimes(const char *, const struct timeval *);
 __END_DECLS
 
 #endif /* !_KERNEL */
diff --git a/sys/sys/timeb.h b/sys/sys/timeb.h
index 238e90e..94aa0df 100644
--- a/sys/sys/timeb.h
+++ b/sys/sys/timeb.h
@@ -54,7 +54,7 @@ struct timeb {
 #include <sys/cdefs.h>
 
 __BEGIN_DECLS
-int ftime __P((struct timeb *));
+int ftime(struct timeb *);
 __END_DECLS
 #endif /* _KERNEL */
 
diff --git a/sys/sys/timepps.h b/sys/sys/timepps.h
index 3c6d39f..a48cc84 100644
--- a/sys/sys/timepps.h
+++ b/sys/sys/timepps.h
@@ -112,10 +112,10 @@ struct pps_state {
 	unsigned	ppscount[3];
 };
 
-void pps_event __P((struct pps_state *pps, struct timecounter *tc, unsigned count, int event));
-void pps_init __P((struct pps_state *pps));
-int pps_ioctl __P((u_long cmd, caddr_t data, struct pps_state *pps));
-void hardpps __P((struct timespec *tsp, long nsec));
+void pps_event(struct pps_state *pps, struct timecounter *tc, unsigned count, int event);
+void pps_init(struct pps_state *pps);
+int pps_ioctl(u_long cmd, caddr_t data, struct pps_state *pps);
+void hardpps(struct timespec *tsp, long nsec);
 
 #else /* !_KERNEL */
 
diff --git a/sys/sys/times.h b/sys/sys/times.h
index 668ac7a..eb68bd0 100644
--- a/sys/sys/times.h
+++ b/sys/sys/times.h
@@ -60,7 +60,7 @@ struct tms {
 #include <sys/cdefs.h>
 
 __BEGIN_DECLS
-clock_t	times __P((struct tms *));
+clock_t	times(struct tms *);
 __END_DECLS
 #endif
 #endif /* !_SYS_TIMES_H_ */
diff --git a/sys/sys/timetc.h b/sys/sys/timetc.h
index 3630908..151cfd6 100644
--- a/sys/sys/timetc.h
+++ b/sys/sys/timetc.h
@@ -65,8 +65,8 @@
  */
 
 struct timecounter;
-typedef unsigned timecounter_get_t __P((struct timecounter *));
-typedef void timecounter_pps_t __P((struct timecounter *));
+typedef unsigned timecounter_get_t(struct timecounter *);
+typedef void timecounter_pps_t(struct timecounter *);
 
 struct timecounter {
 	/* These fields must be initialized by the driver. */
@@ -93,10 +93,10 @@ struct timecounter {
 #ifdef _KERNEL
 extern struct timecounter *volatile timecounter;
 
-void	tc_init __P((struct timecounter *tc));
-void	tc_setclock __P((struct timespec *ts));
-void	tc_windup __P((void));
-void	tc_update __P((struct timecounter *tc));
+void	tc_init(struct timecounter *tc);
+void	tc_setclock(struct timespec *ts);
+void	tc_windup(void);
+void	tc_update(struct timecounter *tc);
 #endif /* !_KERNEL */
 
 #endif /* !_SYS_TIMETC_H_ */
diff --git a/sys/sys/timex.h b/sys/sys/timex.h
index 78b27f4..7cdeea0 100644
--- a/sys/sys/timex.h
+++ b/sys/sys/timex.h
@@ -221,13 +221,13 @@ struct timex {
 
 #ifdef _KERNEL
 struct timecounter;
-void	ntp_update_second __P((struct timecounter *tc));
+void	ntp_update_second(struct timecounter *tc);
 #else /* !_KERNEL */
 #include <sys/cdefs.h>
 
 __BEGIN_DECLS
-int	ntp_adjtime __P((struct timex *));
-int	ntp_gettime __P((struct ntptimeval *));
+int	ntp_adjtime(struct timex *);
+int	ntp_gettime(struct ntptimeval *);
 __END_DECLS
 #endif /* _KERNEL */
 
diff --git a/sys/sys/tty.h b/sys/sys/tty.h
index 82109bd..6c3c674 100644
--- a/sys/sys/tty.h
+++ b/sys/sys/tty.h
@@ -90,11 +90,11 @@ struct tty {
 	struct	termios t_termios;	/* Termios state. */
 	struct	winsize t_winsize;	/* Window size. */
 					/* Start output. */
-	void	(*t_oproc) __P((struct tty *));
+	void	(*t_oproc)(struct tty *);
 					/* Stop output. */
-	void	(*t_stop) __P((struct tty *, int));
+	void	(*t_stop)(struct tty *, int);
 					/* Set hardware state. */
-	int	(*t_param) __P((struct tty *, struct termios *));
+	int	(*t_param)(struct tty *, struct termios *);
 	void	*t_sc;			/* XXX: net/if_sl.c:sl_softc. */
 	int	t_column;		/* Tty output column. */
 	int	t_rocount, t_rocol;	/* Tty. */
@@ -231,51 +231,51 @@ MALLOC_DECLARE(M_TTYS);
 #endif
 extern	struct tty *constty;	/* Temporary virtual console. */
 
-int	 b_to_q __P((char *cp, int cc, struct clist *q));
-void	 catq __P((struct clist *from, struct clist *to));
-void	 clist_alloc_cblocks __P((struct clist *q, int ccmax, int ccres));
-void	 clist_free_cblocks __P((struct clist *q));
-int	 getc __P((struct clist *q));
-void	 ndflush __P((struct clist *q, int cc));
-char	*nextc __P((struct clist *q, char *cp, int *c));
-void	 nottystop __P((struct tty *tp, int rw));
-int	 putc __P((int c, struct clist *q));
-int	 q_to_b __P((struct clist *q, char *cp, int cc));
-void	 termioschars __P((struct termios *t));
-int	 tputchar __P((int c, struct tty *tp));
-int	 ttcompat __P((struct tty *tp, u_long com, caddr_t data, int flag));
-int	 ttioctl __P((struct tty *tp, u_long com, void *data, int flag));
-int	 ttread __P((struct tty *tp, struct uio *uio, int flag));
-void	 ttrstrt __P((void *tp));
-int	 ttsetcompat __P((struct tty *tp, u_long *com, caddr_t data,
-	    struct termios *term));
-void	 ttsetwater __P((struct tty *tp));
-int	 ttspeedtab __P((int speed, struct speedtab *table));
-int	 ttstart __P((struct tty *tp));
-void	 ttwakeup __P((struct tty *tp));
-int	 ttwrite __P((struct tty *tp, struct uio *uio, int flag));
-void	 ttwwakeup __P((struct tty *tp));
-void	 ttyblock __P((struct tty *tp));
-void	 ttychars __P((struct tty *tp));
-int	 ttycheckoutq __P((struct tty *tp, int wait));
-int	 ttyclose __P((struct tty *tp));
-void	 ttyflush __P((struct tty *tp, int rw));
-void	 ttyfree __P((struct tty *tp));
-void	 ttyinfo __P((struct tty *tp));
-int	 ttyinput __P((int c, struct tty *tp));
-int	 ttykqfilter __P((dev_t dev, struct knote *kn));
-int	 ttylclose __P((struct tty *tp, int flag));
-struct tty *ttymalloc __P((struct tty *tp));
-int	 ttymodem __P((struct tty *tp, int flag));
-int	 ttyopen __P((dev_t device, struct tty *tp));
-int	 ttypoll __P((dev_t dev, int events, struct thread *td));
-int	 ttyread __P((dev_t dev, struct uio *uio, int flag));
-void	 ttyregister __P((struct tty *tp));
-int	 ttysleep __P((struct tty *tp, void *chan, int pri, char *wmesg,
-	    int timeout));
-int	 ttywait __P((struct tty *tp));
-int	 ttywrite __P((dev_t dev, struct uio *uio, int flag));
-int	 unputc __P((struct clist *q));
+int	 b_to_q(char *cp, int cc, struct clist *q);
+void	 catq(struct clist *from, struct clist *to);
+void	 clist_alloc_cblocks(struct clist *q, int ccmax, int ccres);
+void	 clist_free_cblocks(struct clist *q);
+int	 getc(struct clist *q);
+void	 ndflush(struct clist *q, int cc);
+char	*nextc(struct clist *q, char *cp, int *c);
+void	 nottystop(struct tty *tp, int rw);
+int	 putc(int c, struct clist *q);
+int	 q_to_b(struct clist *q, char *cp, int cc);
+void	 termioschars(struct termios *t);
+int	 tputchar(int c, struct tty *tp);
+int	 ttcompat(struct tty *tp, u_long com, caddr_t data, int flag);
+int	 ttioctl(struct tty *tp, u_long com, void *data, int flag);
+int	 ttread(struct tty *tp, struct uio *uio, int flag);
+void	 ttrstrt(void *tp);
+int	 ttsetcompat(struct tty *tp, u_long *com, caddr_t data,
+	    struct termios *term);
+void	 ttsetwater(struct tty *tp);
+int	 ttspeedtab(int speed, struct speedtab *table);
+int	 ttstart(struct tty *tp);
+void	 ttwakeup(struct tty *tp);
+int	 ttwrite(struct tty *tp, struct uio *uio, int flag);
+void	 ttwwakeup(struct tty *tp);
+void	 ttyblock(struct tty *tp);
+void	 ttychars(struct tty *tp);
+int	 ttycheckoutq(struct tty *tp, int wait);
+int	 ttyclose(struct tty *tp);
+void	 ttyflush(struct tty *tp, int rw);
+void	 ttyfree(struct tty *tp);
+void	 ttyinfo(struct tty *tp);
+int	 ttyinput(int c, struct tty *tp);
+int	 ttykqfilter(dev_t dev, struct knote *kn);
+int	 ttylclose(struct tty *tp, int flag);
+struct tty *ttymalloc(struct tty *tp);
+int	 ttymodem(struct tty *tp, int flag);
+int	 ttyopen(dev_t device, struct tty *tp);
+int	 ttypoll(dev_t dev, int events, struct thread *td);
+int	 ttyread(dev_t dev, struct uio *uio, int flag);
+void	 ttyregister(struct tty *tp);
+int	 ttysleep(struct tty *tp, void *chan, int pri, char *wmesg,
+	    int timeout);
+int	 ttywait(struct tty *tp);
+int	 ttywrite(dev_t dev, struct uio *uio, int flag);
+int	 unputc(struct clist *q);
 
 #endif /* _KERNEL */
 
diff --git a/sys/sys/types.h b/sys/sys/types.h
index b4babf5..3ca467f 100644
--- a/sys/sys/types.h
+++ b/sys/sys/types.h
@@ -204,19 +204,19 @@ typedef	struct fd_set {
 __BEGIN_DECLS
 #ifndef _FTRUNCATE_DECLARED
 #define	_FTRUNCATE_DECLARED
-int	 ftruncate __P((int, off_t));
+int	 ftruncate(int, off_t);
 #endif
 #ifndef _LSEEK_DECLARED
 #define	_LSEEK_DECLARED
-off_t	 lseek __P((int, off_t, int));
+off_t	 lseek(int, off_t, int);
 #endif
 #ifndef _MMAP_DECLARED
 #define	_MMAP_DECLARED
-void *	 mmap __P((void *, size_t, int, int, int, off_t));
+void *	 mmap(void *, size_t, int, int, int, off_t);
 #endif
 #ifndef _TRUNCATE_DECLARED
 #define	_TRUNCATE_DECLARED
-int	 truncate __P((const char *, off_t));
+int	 truncate(const char *, off_t);
 #endif
 __END_DECLS
 #endif /* !_KERNEL */
diff --git a/sys/sys/uio.h b/sys/sys/uio.h
index e305316..e09ca3f 100644
--- a/sys/sys/uio.h
+++ b/sys/sys/uio.h
@@ -84,21 +84,21 @@ struct uio {
 
 struct vm_object;
 
-void	uio_yield __P((void));
-int	uiomove __P((caddr_t, int, struct uio *));
-int	uiomoveco __P((caddr_t, int, struct uio *, struct vm_object *));
-int	uioread __P((int, struct uio *, struct vm_object *, int *));
-int	copyinfrom __P((const void *src, void *dst, size_t len, int seg));
-int	copyinstrfrom __P((const void *src, void *dst, size_t len,
-	    size_t *copied, int seg));
+void	uio_yield(void);
+int	uiomove(caddr_t, int, struct uio *);
+int	uiomoveco(caddr_t, int, struct uio *, struct vm_object *);
+int	uioread(int, struct uio *, struct vm_object *, int *);
+int	copyinfrom(const void *src, void *dst, size_t len, int seg);
+int	copyinstrfrom(const void *src, void *dst, size_t len,
+	    size_t *copied, int seg);
 
 #else /* !_KERNEL */
 
 #include <sys/cdefs.h>
 
 __BEGIN_DECLS
-ssize_t	readv __P((int, const struct iovec *, int));
-ssize_t	writev __P((int, const struct iovec *, int));
+ssize_t	readv(int, const struct iovec *, int);
+ssize_t	writev(int, const struct iovec *, int);
 __END_DECLS
 
 #endif /* _KERNEL */
diff --git a/sys/sys/un.h b/sys/sys/un.h
index e4ce14c..e0f14f7 100644
--- a/sys/sys/un.h
+++ b/sys/sys/un.h
@@ -54,13 +54,13 @@ struct mbuf;
 struct socket;
 struct sockopt;
 
-int	uipc_ctloutput __P((struct socket *so, struct sockopt *sopt));
-int	uipc_usrreq __P((struct socket *so, int req, struct mbuf *m,
-		struct mbuf *nam, struct mbuf *control));
-int	unp_connect2 __P((struct socket *so, struct socket *so2));
-void	unp_dispose __P((struct mbuf *m));
-int	unp_externalize __P((struct mbuf *mbuf, struct mbuf **controlp));
-void	unp_init __P((void));
+int	uipc_ctloutput(struct socket *so, struct sockopt *sopt);
+int	uipc_usrreq(struct socket *so, int req, struct mbuf *m,
+		struct mbuf *nam, struct mbuf *control);
+int	unp_connect2(struct socket *so, struct socket *so2);
+void	unp_dispose(struct mbuf *m);
+int	unp_externalize(struct mbuf *mbuf, struct mbuf **controlp);
+void	unp_init(void);
 extern	struct pr_usrreqs uipc_usrreqs;
 #else /* !_KERNEL */
 
diff --git a/sys/sys/user.h b/sys/sys/user.h
index 0e61f65..de49e92 100644
--- a/sys/sys/user.h
+++ b/sys/sys/user.h
@@ -167,7 +167,7 @@ struct kinfo_proc {
 	void	*ki_kstack;		/* kernel virtual addr of stack */
 	long	ki_spare[22];		/* spare constants */
 };
-void fill_kinfo_proc __P((struct proc *, struct kinfo_proc *));
+void fill_kinfo_proc(struct proc *, struct kinfo_proc *);
 
 /* ki_sessflag values */
 #define	KI_CTTY		0x00000001	/* controlling tty vnode active */
diff --git a/sys/sys/vnode.h b/sys/sys/vnode.h
index 48ddec2..d8b2bd9 100644
--- a/sys/sys/vnode.h
+++ b/sys/sys/vnode.h
@@ -80,7 +80,7 @@ enum vtagtype	{
  */
 TAILQ_HEAD(buflists, buf);
 
-typedef	int	vop_t __P((void *));
+typedef	int	vop_t(void *);
 struct namecache;
 
 struct vpollinfo {
@@ -315,7 +315,7 @@ extern	int vfs_ioopt;
 #define	LEASE_WRITE	0x2		/* Check lease for modifiers */
 
 
-extern void	(*lease_updatetime) __P((int deltat));
+extern void	(*lease_updatetime)(int deltat);
 
 #define	VSHOULDFREE(vp)	\
 	(!((vp)->v_flag & (VFREE|VDOOMED)) && \
@@ -564,125 +564,125 @@ struct uio;
 struct vattr;
 struct vnode;
 
-extern int	(*lease_check_hook) __P((struct vop_lease_args *));
+extern int	(*lease_check_hook)(struct vop_lease_args *);
 
-struct	vnode *addaliasu __P((struct vnode *vp, udev_t nvp_rdev));
-int	bdevvp __P((dev_t dev, struct vnode **vpp));
+struct	vnode *addaliasu(struct vnode *vp, udev_t nvp_rdev);
+int	bdevvp(dev_t dev, struct vnode **vpp);
 /* cache_* may belong in namei.h. */
-void	cache_enter __P((struct vnode *dvp, struct vnode *vp,
-	    struct componentname *cnp));
-int	cache_lookup __P((struct vnode *dvp, struct vnode **vpp,
-	    struct componentname *cnp));
-void	cache_purge __P((struct vnode *vp));
-void	cache_purgevfs __P((struct mount *mp));
-int	cache_leaf_test __P((struct vnode *vp));
-void	cvtstat __P((struct stat *st, struct ostat *ost));
-void	cvtnstat __P((struct stat *sb, struct nstat *nsb));
-int	getnewvnode __P((enum vtagtype tag,
-	    struct mount *mp, vop_t **vops, struct vnode **vpp));
-int	lease_check __P((struct vop_lease_args *ap));
-int	spec_vnoperate __P((struct vop_generic_args *));
-int	speedup_syncer __P((void));
+void	cache_enter(struct vnode *dvp, struct vnode *vp,
+	    struct componentname *cnp);
+int	cache_lookup(struct vnode *dvp, struct vnode **vpp,
+	    struct componentname *cnp);
+void	cache_purge(struct vnode *vp);
+void	cache_purgevfs(struct mount *mp);
+int	cache_leaf_test(struct vnode *vp);
+void	cvtstat(struct stat *st, struct ostat *ost);
+void	cvtnstat(struct stat *sb, struct nstat *nsb);
+int	getnewvnode(enum vtagtype tag,
+	    struct mount *mp, vop_t **vops, struct vnode **vpp);
+int	lease_check(struct vop_lease_args *ap);
+int	spec_vnoperate(struct vop_generic_args *);
+int	speedup_syncer(void);
 #define textvp_fullpath(p, rb, rfb) \
 	vn_fullpath(FIRST_THREAD_IN_PROC(p), (p)->p_textvp, rb, rfb)
-int	vn_fullpath __P((struct thread *td, struct vnode *vn,
-	    char **retbuf, char **freebuf));
-int	vaccess __P((enum vtype type, mode_t file_mode, uid_t uid, gid_t gid,
-	    mode_t acc_mode, struct ucred *cred, int *privused));
-int	vaccess_acl_posix1e __P((enum vtype type, uid_t file_uid,
+int	vn_fullpath(struct thread *td, struct vnode *vn,
+	    char **retbuf, char **freebuf);
+int	vaccess(enum vtype type, mode_t file_mode, uid_t uid, gid_t gid,
+	    mode_t acc_mode, struct ucred *cred, int *privused);
+int	vaccess_acl_posix1e(enum vtype type, uid_t file_uid,
 	    gid_t file_gid, struct acl *acl, mode_t acc_mode,
-	    struct ucred *cred, int *privused));
-void	vattr_null __P((struct vattr *vap));
-int	vcount __P((struct vnode *vp));
-void	vdrop __P((struct vnode *));
-int	vfinddev __P((dev_t dev, enum vtype type, struct vnode **vpp));
-void	vfs_add_vnodeops __P((const void *));
-void	vfs_rm_vnodeops __P((const void *));
-int	vflush __P((struct mount *mp, int rootrefs, int flags));
-int	vget __P((struct vnode *vp, int lockflag, struct thread *td));
-void	vgone __P((struct vnode *vp));
-void	vgonel __P((struct vnode *vp, struct thread *td));
-void	vhold __P((struct vnode *));
-int	vinvalbuf __P((struct vnode *vp, int save, struct ucred *cred,
-	    struct thread *td, int slpflag, int slptimeo));
-int	vtruncbuf __P((struct vnode *vp, struct ucred *cred, struct thread *td,
-	    off_t length, int blksize));
-void	vprint __P((char *label, struct vnode *vp));
-int	vrecycle __P((struct vnode *vp, struct mtx *inter_lkp,
-	    struct thread *td));
-int	vn_close __P((struct vnode *vp,
-	    int flags, struct ucred *cred, struct thread *td));
-void	vn_finished_write __P((struct mount *mp));
-int	vn_isdisk __P((struct vnode *vp, int *errp));
-int	vn_lock __P((struct vnode *vp, int flags, struct thread *td));
+	    struct ucred *cred, int *privused);
+void	vattr_null(struct vattr *vap);
+int	vcount(struct vnode *vp);
+void	vdrop(struct vnode *);
+int	vfinddev(dev_t dev, enum vtype type, struct vnode **vpp);
+void	vfs_add_vnodeops(const void *);
+void	vfs_rm_vnodeops(const void *);
+int	vflush(struct mount *mp, int rootrefs, int flags);
+int	vget(struct vnode *vp, int lockflag, struct thread *td);
+void	vgone(struct vnode *vp);
+void	vgonel(struct vnode *vp, struct thread *td);
+void	vhold(struct vnode *);
+int	vinvalbuf(struct vnode *vp, int save, struct ucred *cred,
+	    struct thread *td, int slpflag, int slptimeo);
+int	vtruncbuf(struct vnode *vp, struct ucred *cred, struct thread *td,
+	    off_t length, int blksize);
+void	vprint(char *label, struct vnode *vp);
+int	vrecycle(struct vnode *vp, struct mtx *inter_lkp,
+	    struct thread *td);
+int	vn_close(struct vnode *vp,
+	    int flags, struct ucred *cred, struct thread *td);
+void	vn_finished_write(struct mount *mp);
+int	vn_isdisk(struct vnode *vp, int *errp);
+int	vn_lock(struct vnode *vp, int flags, struct thread *td);
 #ifdef	DEBUG_LOCKS
-int	debug_vn_lock __P((struct vnode *vp, int flags, struct thread *p,
-	    const char *filename, int line));
+int	debug_vn_lock(struct vnode *vp, int flags, struct thread *p,
+	    const char *filename, int line);
 #define vn_lock(vp,flags,p) debug_vn_lock(vp,flags,p,__FILE__,__LINE__)
 #endif
-int	vn_mkdir __P((char *path, int mode, enum uio_seg segflg, struct thread *td));
-int	vn_open __P((struct nameidata *ndp, int *flagp, int cmode));
-int	vn_open_cred __P((struct nameidata *ndp, int *flagp, int cmode,
-	    struct ucred *cred));
-void	vn_pollevent __P((struct vnode *vp, int events));
-void	vn_pollgone __P((struct vnode *vp));
-int	vn_pollrecord __P((struct vnode *vp, struct thread *p, int events));
-int	vn_rdwr __P((enum uio_rw rw, struct vnode *vp, caddr_t base,
+int	vn_mkdir(char *path, int mode, enum uio_seg segflg, struct thread *td);
+int	vn_open(struct nameidata *ndp, int *flagp, int cmode);
+int	vn_open_cred(struct nameidata *ndp, int *flagp, int cmode,
+	    struct ucred *cred);
+void	vn_pollevent(struct vnode *vp, int events);
+void	vn_pollgone(struct vnode *vp);
+int	vn_pollrecord(struct vnode *vp, struct thread *p, int events);
+int	vn_rdwr(enum uio_rw rw, struct vnode *vp, caddr_t base,
 	    int len, off_t offset, enum uio_seg segflg, int ioflg,
-	    struct ucred *cred, int *aresid, struct thread *td));
-int	vn_rdwr_inchunks __P((enum uio_rw rw, struct vnode *vp, caddr_t base,
+	    struct ucred *cred, int *aresid, struct thread *td);
+int	vn_rdwr_inchunks(enum uio_rw rw, struct vnode *vp, caddr_t base,
 	    int len, off_t offset, enum uio_seg segflg, int ioflg,
-	    struct ucred *cred, int *aresid, struct thread *td));
-int	vn_stat __P((struct vnode *vp, struct stat *sb, struct thread *td));
-int	vn_start_write __P((struct vnode *vp, struct mount **mpp, int flags));
-dev_t	vn_todev __P((struct vnode *vp));
-int	vn_write_suspend_wait __P((struct vnode *vp, struct mount *mp,
-	    int flags));
-int	vn_writechk __P((struct vnode *vp));
-int	vn_extattr_get __P((struct vnode *vp, int ioflg, int attrnamespace,
-	    const char *attrname, int *buflen, char *buf, struct thread *td));
-int	vn_extattr_set __P((struct vnode *vp, int ioflg, int attrnamespace,
-	    const char *attrname, int buflen, char *buf, struct thread *td));
+	    struct ucred *cred, int *aresid, struct thread *td);
+int	vn_stat(struct vnode *vp, struct stat *sb, struct thread *td);
+int	vn_start_write(struct vnode *vp, struct mount **mpp, int flags);
+dev_t	vn_todev(struct vnode *vp);
+int	vn_write_suspend_wait(struct vnode *vp, struct mount *mp,
+	    int flags);
+int	vn_writechk(struct vnode *vp);
+int	vn_extattr_get(struct vnode *vp, int ioflg, int attrnamespace,
+	    const char *attrname, int *buflen, char *buf, struct thread *td);
+int	vn_extattr_set(struct vnode *vp, int ioflg, int attrnamespace,
+	    const char *attrname, int buflen, char *buf, struct thread *td);
 int	vn_extattr_rm(struct vnode *vp, int ioflg, int attrnamespace,
 	    const char *attrname, struct thread *td);
-int	vfs_cache_lookup __P((struct vop_lookup_args *ap));
-int	vfs_object_create __P((struct vnode *vp, struct thread *td,
-	    struct ucred *cred));
-void	vfs_timestamp __P((struct timespec *));
-void	vfs_write_resume __P((struct mount *mp));
-void	vfs_write_suspend __P((struct mount *mp));
-int	vop_stdbmap __P((struct vop_bmap_args *));
-int	vop_stdgetwritemount __P((struct vop_getwritemount_args *));
-int	vop_stdgetpages __P((struct vop_getpages_args *));
-int	vop_stdinactive __P((struct vop_inactive_args *));
-int	vop_stdislocked __P((struct vop_islocked_args *));
-int	vop_stdlock __P((struct vop_lock_args *));
-int	vop_stdputpages __P((struct vop_putpages_args *));
-int	vop_stdunlock __P((struct vop_unlock_args *));
-int	vop_noislocked __P((struct vop_islocked_args *));
-int	vop_nolock __P((struct vop_lock_args *));
-int	vop_nopoll __P((struct vop_poll_args *));
-int	vop_nounlock __P((struct vop_unlock_args *));
-int	vop_stdpathconf __P((struct vop_pathconf_args *));
-int	vop_stdpoll __P((struct vop_poll_args *));
-int	vop_revoke __P((struct vop_revoke_args *));
-int	vop_sharedlock __P((struct vop_lock_args *));
-int	vop_eopnotsupp __P((struct vop_generic_args *ap));
-int	vop_ebadf __P((struct vop_generic_args *ap));
-int	vop_einval __P((struct vop_generic_args *ap));
-int	vop_enotty __P((struct vop_generic_args *ap));
-int	vop_defaultop __P((struct vop_generic_args *ap));
-int	vop_null __P((struct vop_generic_args *ap));
-int	vop_panic __P((struct vop_generic_args *ap));
-int	vop_stdcreatevobject __P((struct vop_createvobject_args *ap));
-int	vop_stddestroyvobject __P((struct vop_destroyvobject_args *ap));
-int	vop_stdgetvobject __P((struct vop_getvobject_args *ap));
-
-void	vfree __P((struct vnode *));
-void	vput __P((struct vnode *vp));
-void	vrele __P((struct vnode *vp));
-void	vref __P((struct vnode *vp));
-void	vbusy __P((struct vnode *vp));
+int	vfs_cache_lookup(struct vop_lookup_args *ap);
+int	vfs_object_create(struct vnode *vp, struct thread *td,
+	    struct ucred *cred);
+void	vfs_timestamp(struct timespec *);
+void	vfs_write_resume(struct mount *mp);
+void	vfs_write_suspend(struct mount *mp);
+int	vop_stdbmap(struct vop_bmap_args *);
+int	vop_stdgetwritemount(struct vop_getwritemount_args *);
+int	vop_stdgetpages(struct vop_getpages_args *);
+int	vop_stdinactive(struct vop_inactive_args *);
+int	vop_stdislocked(struct vop_islocked_args *);
+int	vop_stdlock(struct vop_lock_args *);
+int	vop_stdputpages(struct vop_putpages_args *);
+int	vop_stdunlock(struct vop_unlock_args *);
+int	vop_noislocked(struct vop_islocked_args *);
+int	vop_nolock(struct vop_lock_args *);
+int	vop_nopoll(struct vop_poll_args *);
+int	vop_nounlock(struct vop_unlock_args *);
+int	vop_stdpathconf(struct vop_pathconf_args *);
+int	vop_stdpoll(struct vop_poll_args *);
+int	vop_revoke(struct vop_revoke_args *);
+int	vop_sharedlock(struct vop_lock_args *);
+int	vop_eopnotsupp(struct vop_generic_args *ap);
+int	vop_ebadf(struct vop_generic_args *ap);
+int	vop_einval(struct vop_generic_args *ap);
+int	vop_enotty(struct vop_generic_args *ap);
+int	vop_defaultop(struct vop_generic_args *ap);
+int	vop_null(struct vop_generic_args *ap);
+int	vop_panic(struct vop_generic_args *ap);
+int	vop_stdcreatevobject(struct vop_createvobject_args *ap);
+int	vop_stddestroyvobject(struct vop_destroyvobject_args *ap);
+int	vop_stdgetvobject(struct vop_getvobject_args *ap);
+
+void	vfree(struct vnode *);
+void	vput(struct vnode *vp);
+void	vrele(struct vnode *vp);
+void	vref(struct vnode *vp);
+void	vbusy(struct vnode *vp);
 void 	v_addpollinfo(struct vnode *vp);
 
 extern	vop_t **default_vnodeop_p;
diff --git a/sys/sys/wait.h b/sys/sys/wait.h
index 036dda8..cdd3d1e 100644
--- a/sys/sys/wait.h
+++ b/sys/sys/wait.h
@@ -151,11 +151,11 @@ union wait {
 __BEGIN_DECLS
 struct rusage;	/* forward declaration */
 
-pid_t	wait __P((int *));
-pid_t	waitpid __P((pid_t, int *, int));
+pid_t	wait(int *);
+pid_t	waitpid(pid_t, int *, int);
 #ifndef _POSIX_SOURCE
-pid_t	wait3 __P((int *, int, struct rusage *));
-pid_t	wait4 __P((pid_t, int *, int, struct rusage *));
+pid_t	wait3(int *, int, struct rusage *);
+pid_t	wait4(pid_t, int *, int, struct rusage *);
 #endif
 __END_DECLS
 #endif