Update to FreeBSD head 2017-08-01

Git mirror commit f5002f5e5f78cae9f0269d812dc0aedb0339312c.

Update #3472.

18 files changed, 229 insertions, 252 deletions

diff --git a/freebsd/sys/sys/_pctrie.h b/freebsd/sys/sys/_pctrie.h
index 45f69b20..c6d13baa 100644
--- a/freebsd/sys/sys/_pctrie.h
+++ b/freebsd/sys/sys/_pctrie.h
@@ -38,14 +38,4 @@ struct pctrie {
 	uintptr_t	pt_root;
 };
 
-#ifdef _KERNEL
-
-static __inline boolean_t
-pctrie_is_empty(struct pctrie *ptree)
-{
-
-	return (ptree->pt_root == 0);
-}
-
-#endif /* _KERNEL */
 #endif /* !__SYS_PCTRIE_H_ */
diff --git a/freebsd/sys/sys/ata.h b/freebsd/sys/sys/ata.h
index 0ed78ec8..4d3b3e7f 100644
--- a/freebsd/sys/sys/ata.h
+++ b/freebsd/sys/sys/ata.h
@@ -68,8 +68,8 @@ struct ata_params {
 /*049*/ u_int16_t       capabilities1;
 #define ATA_SUPPORT_DMA                 0x0100
 #define ATA_SUPPORT_LBA                 0x0200
-#define ATA_SUPPORT_IORDY               0x0400
-#define ATA_SUPPORT_IORDYDIS            0x0800
+#define ATA_SUPPORT_IORDYDIS            0x0400
+#define ATA_SUPPORT_IORDY               0x0800
 #define ATA_SUPPORT_OVERLAP             0x4000
 
 /*050*/ u_int16_t       capabilities2;
diff --git a/freebsd/sys/sys/blist.h b/freebsd/sys/sys/blist.h
index f2e81ec8..292f9b97 100644
--- a/freebsd/sys/sys/blist.h
+++ b/freebsd/sys/sys/blist.h
@@ -44,7 +44,7 @@
  *		ops.
  *
  *		SWAPBLK_NONE is returned on failure.  This module is typically
- *		capable of managing up to (2^31) blocks per blist, though
+ *		capable of managing up to (2^63) blocks per blist, though
  *		the memory utilization would be insane if you actually did
  *		that.  Managing something like 512MB worth of 4K blocks 
  *		eats around 32 KBytes of memory. 
@@ -56,7 +56,7 @@
 #ifndef _SYS_BLIST_H_
 #define _SYS_BLIST_H_
 
-typedef	u_int32_t	u_daddr_t;	/* unsigned disk address */
+typedef	uint64_t	u_daddr_t;	/* unsigned disk address */
 
 /*
  * note: currently use SWAPBLK_NONE as an absolute value rather then 
@@ -67,7 +67,7 @@ typedef	u_int32_t	u_daddr_t;	/* unsigned disk address */
 #define SWAPBLK_NONE	((daddr_t)((u_daddr_t)SWAPBLK_MASK + 1))/* flag */
 
 /*
- * blmeta and bl_bitmap_t MUST be a power of 2 in size.
+ * Both blmeta and bmu_bitmap MUST be a power of 2 in size.
  */
 
 typedef struct blmeta {
@@ -82,9 +82,8 @@ typedef struct blist {
 	daddr_t		bl_blocks;	/* area of coverage		*/
 	daddr_t		bl_radix;	/* coverage radix		*/
 	daddr_t		bl_skip;	/* starting skip		*/
-	daddr_t		bl_free;	/* number of free blocks	*/
+	daddr_t		bl_cursor;	/* next-fit search starts at	*/
 	blmeta_t	*bl_root;	/* root of radix tree		*/
-	daddr_t		bl_rootblks;	/* daddr_t blks allocated for tree */
 } *blist_t;
 
 #define BLIST_META_RADIX	16
@@ -92,13 +91,14 @@ typedef struct blist {
 
 #define BLIST_MAX_ALLOC		BLIST_BMAP_RADIX
 
-extern blist_t blist_create(daddr_t blocks, int flags);
-extern void blist_destroy(blist_t blist);
-extern daddr_t blist_alloc(blist_t blist, daddr_t count);
-extern void blist_free(blist_t blist, daddr_t blkno, daddr_t count);
-extern int blist_fill(blist_t bl, daddr_t blkno, daddr_t count);
-extern void blist_print(blist_t blist);
-extern void blist_resize(blist_t *pblist, daddr_t count, int freenew, int flags);
+daddr_t	blist_alloc(blist_t blist, daddr_t count);
+daddr_t	blist_avail(blist_t blist);
+blist_t	blist_create(daddr_t blocks, int flags);
+void	blist_destroy(blist_t blist);
+daddr_t	blist_fill(blist_t bl, daddr_t blkno, daddr_t count);
+void	blist_free(blist_t blist, daddr_t blkno, daddr_t count);
+void	blist_print(blist_t blist);
+void	blist_resize(blist_t *pblist, daddr_t count, int freenew, int flags);
 
 #endif	/* _SYS_BLIST_H_ */
 
diff --git a/freebsd/sys/sys/buf.h b/freebsd/sys/sys/buf.h
index 830fb054..58bd91e3 100644
--- a/freebsd/sys/sys/buf.h
+++ b/freebsd/sys/sys/buf.h
@@ -472,6 +472,7 @@ buf_track(struct buf *bp, const char *location)
 extern int	nbuf;			/* The number of buffer headers */
 extern long	maxswzone;		/* Max KVA for swap structures */
 extern long	maxbcache;		/* Max KVA for buffer cache */
+extern int	maxbcachebuf;		/* Max buffer cache block size */
 extern long	runningbufspace;
 extern long	hibufspace;
 extern int	dirtybufthresh;
diff --git a/freebsd/sys/sys/bus_dma.h b/freebsd/sys/sys/bus_dma.h
index 1a2ecd6b..04dbe0cb 100644
--- a/freebsd/sys/sys/bus_dma.h
+++ b/freebsd/sys/sys/bus_dma.h
@@ -248,105 +248,49 @@ int bus_dmamap_load_ma_triv(bus_dma_tag_t dmat, bus_dmamap_t map,
     struct vm_page **ma, bus_size_t tlen, int ma_offs, int flags,
     bus_dma_segment_t *segs, int *segp);
 
-/*
- * XXX sparc64 uses the same interface, but a much different implementation.
- *     <machine/bus_dma.h> for the sparc64 arch contains the equivalent
- *     declarations.
- */
-#if !defined(__sparc64__)
+#ifdef WANT_INLINE_DMAMAP
+#define BUS_DMAMAP_OP static inline
+#else
+#define BUS_DMAMAP_OP
+#endif
 
 /*
  * Allocate a handle for mapping from kva/uva/physical
  * address space into bus device space.
  */
-int bus_dmamap_create(bus_dma_tag_t dmat, int flags, bus_dmamap_t *mapp);
+BUS_DMAMAP_OP int bus_dmamap_create(bus_dma_tag_t dmat, int flags, bus_dmamap_t *mapp);
 
 /*
  * Destroy a handle for mapping from kva/uva/physical
  * address space into bus device space.
  */
-int bus_dmamap_destroy(bus_dma_tag_t dmat, bus_dmamap_t map);
+BUS_DMAMAP_OP int bus_dmamap_destroy(bus_dma_tag_t dmat, bus_dmamap_t map);
 
 /*
  * Allocate a piece of memory that can be efficiently mapped into
  * bus device space based on the constraints listed in the dma tag.
  * A dmamap to for use with dmamap_load is also allocated.
  */
-int bus_dmamem_alloc(bus_dma_tag_t dmat, void** vaddr, int flags,
+BUS_DMAMAP_OP int bus_dmamem_alloc(bus_dma_tag_t dmat, void** vaddr, int flags,
 		     bus_dmamap_t *mapp);
 
 /*
  * Free a piece of memory and its allocated dmamap, that was allocated
  * via bus_dmamem_alloc.
  */
-void bus_dmamem_free(bus_dma_tag_t dmat, void *vaddr, bus_dmamap_t map);
+BUS_DMAMAP_OP void bus_dmamem_free(bus_dma_tag_t dmat, void *vaddr, bus_dmamap_t map);
 
 /*
  * Perform a synchronization operation on the given map. If the map
- * is NULL we have a fully IO-coherent system. On every ARM architecture
- * there must be a memory barrier placed to ensure that all data
- * accesses are visible before going any further.
+ * is NULL we have a fully IO-coherent system.
  */
-void _bus_dmamap_sync(bus_dma_tag_t, bus_dmamap_t, bus_dmasync_op_t);
-#if defined(__arm__)
-	#define __BUS_DMAMAP_SYNC_DEFAULT		mb()
-#elif defined(__aarch64__)
-	#define	__BUS_DMAMAP_SYNC_DEFAULT		dmb(sy)
-#else
-	#define	__BUS_DMAMAP_SYNC_DEFAULT		do {} while (0)
-#endif
-#define bus_dmamap_sync(dmat, dmamap, op) 			\
-	do {							\
-		if ((dmamap) != NULL)				\
-			_bus_dmamap_sync(dmat, dmamap, op);	\
-		else						\
-			__BUS_DMAMAP_SYNC_DEFAULT;		\
-	} while (0)
+BUS_DMAMAP_OP void bus_dmamap_sync(bus_dma_tag_t dmat, bus_dmamap_t dmamap, bus_dmasync_op_t op);
 
 /*
  * Release the mapping held by map.
  */
-void _bus_dmamap_unload(bus_dma_tag_t dmat, bus_dmamap_t map);
-#define bus_dmamap_unload(dmat, dmamap) 			\
-	do {							\
-		if ((dmamap) != NULL)				\
-			_bus_dmamap_unload(dmat, dmamap);	\
-	} while (0)
-
-/*
- * The following functions define the interface between the MD and MI
- * busdma layers.  These are not intended for consumption by driver
- * software.
- */
-void __bus_dmamap_waitok(bus_dma_tag_t dmat, bus_dmamap_t map,
-			 struct memdesc *mem,
-    			 bus_dmamap_callback_t *callback,
-			 void *callback_arg);
-
-#define	_bus_dmamap_waitok(dmat, map, mem, callback, callback_arg)	\
-	do {								\
-		if ((map) != NULL)					\
-			__bus_dmamap_waitok(dmat, map, mem, callback,	\
-			    callback_arg);				\
-	} while (0);
-
-int _bus_dmamap_load_buffer(bus_dma_tag_t dmat, bus_dmamap_t map,
-			    void *buf, bus_size_t buflen, struct pmap *pmap,
-			    int flags, bus_dma_segment_t *segs, int *segp);
-
-int _bus_dmamap_load_phys(bus_dma_tag_t dmat, bus_dmamap_t map,
-			  vm_paddr_t paddr, bus_size_t buflen,
-			  int flags, bus_dma_segment_t *segs, int *segp);
-
-int _bus_dmamap_load_ma(bus_dma_tag_t dmat, bus_dmamap_t map,
-    struct vm_page **ma, bus_size_t tlen, int ma_offs, int flags,
-    bus_dma_segment_t *segs, int *segp);
-
-bus_dma_segment_t *_bus_dmamap_complete(bus_dma_tag_t dmat,
-			   		bus_dmamap_t map,
-					bus_dma_segment_t *segs,
-					int nsegs, int error);
+BUS_DMAMAP_OP void bus_dmamap_unload(bus_dma_tag_t dmat, bus_dmamap_t dmamap);
 
-#endif /* __sparc64__ */
+#undef BUS_DMAMAP_OP
 
 #endif /* _BUS_DMA_H_ */
diff --git a/freebsd/sys/sys/jail.h b/freebsd/sys/sys/jail.h
index c67c8f55..bc9025cf 100644
--- a/freebsd/sys/sys/jail.h
+++ b/freebsd/sys/sys/jail.h
@@ -215,22 +215,24 @@ struct prison_racct {
 					/* by this jail or an ancestor */
 
 /* Flags for pr_allow */
-#define	PR_ALLOW_SET_HOSTNAME		0x0001
-#define	PR_ALLOW_SYSVIPC		0x0002
-#define	PR_ALLOW_RAW_SOCKETS		0x0004
-#define	PR_ALLOW_CHFLAGS		0x0008
-#define	PR_ALLOW_MOUNT			0x0010
-#define	PR_ALLOW_QUOTAS			0x0020
-#define	PR_ALLOW_SOCKET_AF		0x0040
-#define	PR_ALLOW_MOUNT_DEVFS		0x0080
-#define	PR_ALLOW_MOUNT_NULLFS		0x0100
-#define	PR_ALLOW_MOUNT_ZFS		0x0200
-#define	PR_ALLOW_MOUNT_PROCFS		0x0400
-#define	PR_ALLOW_MOUNT_TMPFS		0x0800
-#define	PR_ALLOW_MOUNT_FDESCFS		0x1000
-#define	PR_ALLOW_MOUNT_LINPROCFS	0x2000
-#define	PR_ALLOW_MOUNT_LINSYSFS		0x4000
-#define	PR_ALLOW_ALL			0x7fff
+#define	PR_ALLOW_SET_HOSTNAME		0x00000001
+#define	PR_ALLOW_SYSVIPC		0x00000002
+#define	PR_ALLOW_RAW_SOCKETS		0x00000004
+#define	PR_ALLOW_CHFLAGS		0x00000008
+#define	PR_ALLOW_MOUNT			0x00000010
+#define	PR_ALLOW_QUOTAS			0x00000020
+#define	PR_ALLOW_SOCKET_AF		0x00000040
+#define	PR_ALLOW_MOUNT_DEVFS		0x00000080
+#define	PR_ALLOW_MOUNT_NULLFS		0x00000100
+#define	PR_ALLOW_MOUNT_ZFS		0x00000200
+#define	PR_ALLOW_MOUNT_PROCFS		0x00000400
+#define	PR_ALLOW_MOUNT_TMPFS		0x00000800
+#define	PR_ALLOW_MOUNT_FDESCFS		0x00001000
+#define	PR_ALLOW_MOUNT_LINPROCFS	0x00002000
+#define	PR_ALLOW_MOUNT_LINSYSFS		0x00004000
+#define	PR_ALLOW_RESERVED_PORTS		0x00008000
+#define	PR_ALLOW_KMEM_ACCESS		0x00010000	/* reserved, not used yet */
+#define	PR_ALLOW_ALL			0x0001ffff
 
 /*
  * OSD methods
diff --git a/freebsd/sys/sys/module.h b/freebsd/sys/sys/module.h
index 71aa9954..5a268fc1 100644
--- a/freebsd/sys/sys/module.h
+++ b/freebsd/sys/sys/module.h
@@ -106,14 +106,15 @@ struct mod_pnp_match_info
 
 #include <sys/linker_set.h>
 
+#define	MODULE_METADATA_CONCAT(uniquifier)	_mod_metadata##uniquifier
 #define	MODULE_METADATA(uniquifier, type, data, cval)			\
-	static struct mod_metadata _mod_metadata##uniquifier = {	\
+	static struct mod_metadata MODULE_METADATA_CONCAT(uniquifier) = {	\
 		MDT_STRUCT_VERSION,					\
 		type,							\
 		data,							\
 		cval							\
 	};								\
-	DATA_SET(modmetadata_set, _mod_metadata##uniquifier)
+	DATA_SET(modmetadata_set, MODULE_METADATA_CONCAT(uniquifier))
 
 #define	MODULE_DEPEND(module, mdepend, vmin, vpref, vmax)		\
 	static struct mod_depend _##module##_depend_on_##mdepend	\
@@ -139,7 +140,7 @@ struct mod_pnp_match_info
 #define	DECLARE_MODULE_WITH_MAXVER(name, data, sub, order, maxver)	\
 	MODULE_DEPEND(name, kernel, __FreeBSD_version,			\
 	    __FreeBSD_version, maxver);			\
-	MODULE_METADATA(_md_##name, MDT_MODULE, &data, #name);		\
+	MODULE_METADATA(_md_##name, MDT_MODULE, &data, __XSTRING(name));\
 	SYSINIT(name##module, sub, order, module_register_init, &data);	\
 	struct __hack
 
@@ -156,13 +157,14 @@ struct mod_pnp_match_info
 #define	DECLARE_MODULE_TIED(name, data, sub, order)				\
 	DECLARE_MODULE_WITH_MAXVER(name, data, sub, order, __FreeBSD_version)
 
+#define	MODULE_VERSION_CONCAT(module, version)	_##module##_version
 #define	MODULE_VERSION(module, version)					\
-	static struct mod_version _##module##_version			\
+	static struct mod_version MODULE_VERSION_CONCAT(module, version)\
 	    __section(".data") = {					\
 		version							\
 	};								\
-	MODULE_METADATA(_##module##_version, MDT_VERSION,		\
-	    &_##module##_version, #module)
+	MODULE_METADATA(MODULE_VERSION_CONCAT(module, version), MDT_VERSION,\
+	    &MODULE_VERSION_CONCAT(module, version), __XSTRING(module))
 
 /**
  * Generic macros to create pnp info hints that modules may export
diff --git a/freebsd/sys/sys/proc.h b/freebsd/sys/sys/proc.h
index 0644d68b..b28c19e6 100644
--- a/freebsd/sys/sys/proc.h
+++ b/freebsd/sys/sys/proc.h
@@ -142,6 +142,7 @@ struct pargs {
  *      j - locked by proc slock
  *      k - only accessed by curthread
  *	k*- only accessed by curthread and from an interrupt
+ *	kx- only accessed by curthread and by debugger
  *      l - the attaching proc or attaching proc parent
  *      m - Giant
  *      n - not locked, lazy
@@ -327,11 +328,11 @@ struct thread {
 	u_char		td_pri_class;	/* (t) Scheduling class. */
 	u_char		td_user_pri;	/* (t) User pri from estcpu and nice. */
 	u_char		td_base_user_pri; /* (t) Base user pri */
-	u_int		td_dbg_sc_code;	/* (c) Syscall code to debugger. */
-	u_int		td_dbg_sc_narg;	/* (c) Syscall arg count to debugger.*/
 	uintptr_t	td_rb_list;	/* (k) Robust list head. */
 	uintptr_t	td_rbp_list;	/* (k) Robust priv list head. */
 	uintptr_t	td_rb_inact;	/* (k) Current in-action mutex loc. */
+	struct syscall_args td_sa;	/* (kx) Syscall parameters. Copied on
+					   fork for child tracing. */
 #define	td_endcopy td_pcb
 
 /*
@@ -1119,7 +1120,7 @@ void	userret(struct thread *, struct trapframe *);
 void	cpu_exit(struct thread *);
 void	exit1(struct thread *, int, int) __dead2;
 void	cpu_copy_thread(struct thread *td, struct thread *td0);
-int	cpu_fetch_syscall_args(struct thread *td, struct syscall_args *sa);
+int	cpu_fetch_syscall_args(struct thread *td);
 void	cpu_fork(struct thread *, struct proc *, struct thread *, int);
 void	cpu_fork_kthread_handler(struct thread *, void (*)(void *), void *);
 void	cpu_set_syscall_retval(struct thread *, int);
diff --git a/freebsd/sys/sys/refcount.h b/freebsd/sys/sys/refcount.h
index 32f7f6e4..ea846f8c 100644
--- a/freebsd/sys/sys/refcount.h
+++ b/freebsd/sys/sys/refcount.h
@@ -50,7 +50,7 @@ refcount_acquire(volatile u_int *count)
 {
 
 	KASSERT(*count < UINT_MAX, ("refcount %p overflowed", count));
-	atomic_add_acq_int((volatile int *)count, 1);	
+	atomic_add_int((volatile int *)count, 1);
 }
 
 static __inline int
@@ -58,10 +58,20 @@ refcount_release(volatile u_int *count)
 {
 	u_int old;
 
-	/* XXX: Should this have a rel membar? */
+	atomic_thread_fence_rel();
 	old = atomic_fetchadd_int((volatile int *)count, -1);
 	KASSERT(old > 0, ("negative refcount %p", count));
-	return (old == 1);
+	if (old > 1)
+		return (0);
+
+	/*
+	 * Last reference.  Signal the user to call the destructor.
+	 *
+	 * Ensure that the destructor sees all updates.  The fence_rel
+	 * at the start of the function synchronized with this fence.
+	 */
+	atomic_thread_fence_acq();
+	return (1);
 }
 
 #endif	/* ! __SYS_REFCOUNT_H__ */
diff --git a/freebsd/sys/sys/sockbuf.h b/freebsd/sys/sys/sockbuf.h
index b1ebe62f..c9cb4dd7 100644
--- a/freebsd/sys/sys/sockbuf.h
+++ b/freebsd/sys/sys/sockbuf.h
@@ -32,7 +32,6 @@
  */
 #ifndef _SYS_SOCKBUF_H_
 #define _SYS_SOCKBUF_H_
-#include <sys/selinfo.h>		/* for struct selinfo */
 #include <sys/_lock.h>
 #include <sys/_mutex.h>
 #include <sys/_sx.h>
@@ -64,6 +63,7 @@ struct mbuf;
 struct sockaddr;
 struct socket;
 struct thread;
+struct selinfo;
 
 struct	xsockbuf {
 	u_int	sb_cc;
@@ -84,9 +84,9 @@ struct	xsockbuf {
  * (a) locked by SOCKBUF_LOCK().
  */
 struct	sockbuf {
-	struct	selinfo sb_sel;	/* process selecting read/write */
-	struct	mtx sb_mtx;	/* sockbuf lock */
-	struct	sx sb_sx;	/* prevent I/O interlacing */
+	struct	mtx sb_mtx;		/* sockbuf lock */
+	struct	sx sb_sx;		/* prevent I/O interlacing */
+	struct	selinfo *sb_sel;	/* process selecting read/write */
 	short	sb_state;	/* (a) socket state on sockbuf */
 #define	sb_startzero	sb_mb
 	struct	mbuf *sb_mb;	/* (a) the mbuf chain */
@@ -169,8 +169,7 @@ void	sbflush_locked(struct sockbuf *sb);
 void	sbrelease(struct sockbuf *sb, struct socket *so);
 void	sbrelease_internal(struct sockbuf *sb, struct socket *so);
 void	sbrelease_locked(struct sockbuf *sb, struct socket *so);
-int	sbreserve(struct sockbuf *sb, u_long cc, struct socket *so,
-	    struct thread *td);
+int	sbsetopt(struct socket *so, int cmd, u_long cc);
 int	sbreserve_locked(struct sockbuf *sb, u_long cc, struct socket *so,
 	    struct thread *td);
 struct mbuf *
diff --git a/freebsd/sys/sys/socketvar.h b/freebsd/sys/sys/socketvar.h
index 245a687b..0c5b95ec 100644
--- a/freebsd/sys/sys/socketvar.h
+++ b/freebsd/sys/sys/socketvar.h
@@ -55,7 +55,8 @@ struct vnet;
  * handle on protocol and pointer to protocol
  * private data and error information.
  */
-typedef	u_quad_t so_gen_t;
+typedef	uint64_t so_gen_t;
+typedef	int so_upcall_t(struct socket *, void *, int);
 
 struct socket;
 
@@ -63,60 +64,35 @@ struct socket;
  * Locking key to struct socket:
  * (a) constant after allocation, no locking required.
  * (b) locked by SOCK_LOCK(so).
- * (c) locked by SOCKBUF_LOCK(&so->so_rcv).
- * (e) locked by ACCEPT_LOCK().
+ * (cr) locked by SOCKBUF_LOCK(&so->so_rcv).
+ * (cs) locked by SOCKBUF_LOCK(&so->so_rcv).
+ * (e) locked by SOLISTEN_LOCK() of corresponding listening socket.
  * (f) not locked since integer reads/writes are atomic.
  * (g) used only as a sleep/wakeup address, no value.
  * (h) locked by global mutex so_global_mtx.
  */
+TAILQ_HEAD(accept_queue, socket);
 struct socket {
-	int	so_count;		/* (b) reference count */
+	struct mtx	so_lock;
+	volatile u_int	so_count;	/* (b / refcount) */
+	struct selinfo	so_rdsel;	/* (b/cr) for so_rcv/so_comp */
+	struct selinfo	so_wrsel;	/* (b/cs) for so_snd */
 	short	so_type;		/* (a) generic type, see socket.h */
-	short	so_options;		/* from socket call, see socket.h */
-	short	so_linger;		/* time to linger while closing */
+	short	so_options;		/* (b) from socket call, see socket.h */
+	short	so_linger;		/* time to linger close(2) */
 	short	so_state;		/* (b) internal state flags SS_* */
-	int	so_qstate;		/* (e) internal state flags SQ_* */
 	void	*so_pcb;		/* protocol control block */
 	struct	vnet *so_vnet;		/* (a) network stack instance */
 	struct	protosw *so_proto;	/* (a) protocol handle */
-/*
- * Variables for connection queuing.
- * Socket where accepts occur is so_head in all subsidiary sockets.
- * If so_head is 0, socket is not related to an accept.
- * For head socket so_incomp queues partially completed connections,
- * while so_comp is a queue of connections ready to be accepted.
- * If a connection is aborted and it has so_head set, then
- * it has to be pulled out of either so_incomp or so_comp.
- * We allow connections to queue up based on current queue lengths
- * and limit on number of queued connections for this socket.
- */
-	struct	socket *so_head;	/* (e) back pointer to listen socket */
-	TAILQ_HEAD(, socket) so_incomp;	/* (e) queue of partial unaccepted connections */
-	TAILQ_HEAD(, socket) so_comp;	/* (e) queue of complete unaccepted connections */
-	TAILQ_ENTRY(socket) so_list;	/* (e) list of unaccepted connections */
-	u_int	so_qlen;		/* (e) number of unaccepted connections */
-	u_int	so_incqlen;		/* (e) number of unaccepted incomplete
-					   connections */
-	u_int	so_qlimit;		/* (e) max number queued connections */
 	short	so_timeo;		/* (g) connection timeout */
 	u_short	so_error;		/* (f) error affecting connection */
 	struct	sigio *so_sigio;	/* [sg] information for async I/O or
 					   out of band data (SIGURG) */
-	u_long	so_oobmark;		/* (c) chars to oob mark */
-
-	struct sockbuf so_rcv, so_snd;
-
 	struct	ucred *so_cred;		/* (a) user credentials */
 	struct	label *so_label;	/* (b) MAC label for socket */
-	struct	label *so_peerlabel;	/* (b) cached MAC label for peer */
 	/* NB: generation count must not be first. */
 	so_gen_t so_gencnt;		/* (h) generation count */
 	void	*so_emuldata;		/* (b) private data for emulators */
- 	struct so_accf {
-		struct	accept_filter *so_accept_filter;
-		void	*so_accept_filter_arg;	/* saved filter args */
-		char	*so_accept_filter_str;	/* saved user args */
-	} *so_accf;
 	struct	osd	osd;		/* Object Specific extensions */
 	/*
 	 * so_fibnum, so_user_cookie and friends can be used to attach
@@ -129,39 +105,93 @@ struct socket {
 
 	int so_ts_clock;	/* type of the clock used for timestamps */
 	uint32_t so_max_pacing_rate;	/* (f) TX rate limit in bytes/s */
-
-	void *so_pspare[2];	/* general use */
-	int so_ispare[2];	/* general use */
+	union {
+		/* Regular (data flow) socket. */
+		struct {
+			/* (cr, cs) Receive and send buffers. */
+			struct sockbuf		so_rcv, so_snd;
+
+			/* (e) Our place on accept queue. */
+			TAILQ_ENTRY(socket)	so_list;
+			struct socket		*so_listen;	/* (b) */
+			enum {
+				SQ_NONE = 0,
+				SQ_INCOMP = 0x0800,	/* on sol_incomp */
+				SQ_COMP = 0x1000,	/* on sol_comp */
+			}			so_qstate;	/* (b) */
+
+			/* (b) cached MAC label for peer */
+			struct	label		*so_peerlabel;
+			u_long	so_oobmark;	/* chars to oob mark */
+		};
+		/*
+		 * Listening socket, where accepts occur, is so_listen in all
+		 * subsidiary sockets.  If so_listen is NULL, socket is not
+		 * related to an accept.  For a listening socket itself
+		 * sol_incomp queues partially completed connections, while
+		 * sol_comp is a queue of connections ready to be accepted.
+		 * If a connection is aborted and it has so_listen set, then
+		 * it has to be pulled out of either sol_incomp or sol_comp.
+		 * We allow connections to queue up based on current queue
+		 * lengths and limit on number of queued connections for this
+		 * socket.
+		 */
+		struct {
+			/* (e) queue of partial unaccepted connections */
+			struct accept_queue	sol_incomp;
+			/* (e) queue of complete unaccepted connections */
+			struct accept_queue	sol_comp;
+			u_int	sol_qlen;    /* (e) sol_comp length */
+			u_int	sol_incqlen; /* (e) sol_incomp length */
+			u_int	sol_qlimit;  /* (e) queue limit */
+
+			/* accept_filter(9) optional data */
+			struct	accept_filter	*sol_accept_filter;
+			void	*sol_accept_filter_arg;	/* saved filter args */
+			char	*sol_accept_filter_str;	/* saved user args */
+
+			/* Optional upcall, for kernel socket. */
+			so_upcall_t	*sol_upcall;	/* (e) */
+			void		*sol_upcallarg;	/* (e) */
+
+			/* Socket buffer parameters, to be copied to
+			 * dataflow sockets, accepted from this one. */
+			int		sol_sbrcv_lowat;
+			int		sol_sbsnd_lowat;
+			u_int		sol_sbrcv_hiwat;
+			u_int		sol_sbsnd_hiwat;
+			short		sol_sbrcv_flags;
+			short		sol_sbsnd_flags;
+			sbintime_t	sol_sbrcv_timeo;
+			sbintime_t	sol_sbsnd_timeo;
+		};
+	};
 };
 
-/*
- * Global accept mutex to serialize access to accept queues and
- * fields associated with multiple sockets.  This allows us to
- * avoid defining a lock order between listen and accept sockets
- * until such time as it proves to be a good idea.
- */
-extern struct mtx accept_mtx;
-#define	ACCEPT_LOCK_ASSERT()		mtx_assert(&accept_mtx, MA_OWNED)
-#define	ACCEPT_UNLOCK_ASSERT()		mtx_assert(&accept_mtx, MA_NOTOWNED)
-#define	ACCEPT_LOCK()			mtx_lock(&accept_mtx)
-#define	ACCEPT_UNLOCK()			mtx_unlock(&accept_mtx)
-
-/*
- * Per-socket mutex: we reuse the receive socket buffer mutex for space
- * efficiency.  This decision should probably be revisited as we optimize
- * locking for the socket code.
- */
-#define	SOCK_MTX(_so)			SOCKBUF_MTX(&(_so)->so_rcv)
-#define	SOCK_LOCK(_so)			SOCKBUF_LOCK(&(_so)->so_rcv)
-#define	SOCK_OWNED(_so)			SOCKBUF_OWNED(&(_so)->so_rcv)
-#define	SOCK_UNLOCK(_so)		SOCKBUF_UNLOCK(&(_so)->so_rcv)
-#define	SOCK_LOCK_ASSERT(_so)		SOCKBUF_LOCK_ASSERT(&(_so)->so_rcv)
-
-/*
- * Socket state bits stored in so_qstate.
- */
-#define	SQ_INCOMP		0x0800	/* unaccepted, incomplete connection */
-#define	SQ_COMP			0x1000	/* unaccepted, complete connection */
+#define	SOCK_MTX(so)		&(so)->so_lock
+#define	SOCK_LOCK(so)		mtx_lock(&(so)->so_lock)
+#define	SOCK_OWNED(so)		mtx_owned(&(so)->so_lock)
+#define	SOCK_UNLOCK(so)		mtx_unlock(&(so)->so_lock)
+#define	SOCK_LOCK_ASSERT(so)	mtx_assert(&(so)->so_lock, MA_OWNED)
+#define	SOCK_UNLOCK_ASSERT(so)	mtx_assert(&(so)->so_lock, MA_NOTOWNED)
+
+#define	SOLISTENING(sol)	(((sol)->so_options & SO_ACCEPTCONN) != 0)
+#define	SOLISTEN_LOCK(sol)	do {					\
+	mtx_lock(&(sol)->so_lock);					\
+	KASSERT(SOLISTENING(sol),					\
+	    ("%s: %p not listening", __func__, (sol)));			\
+} while (0)
+#define	SOLISTEN_TRYLOCK(sol)	mtx_trylock(&(sol)->so_lock)
+#define	SOLISTEN_UNLOCK(sol)	do {					\
+	KASSERT(SOLISTENING(sol),					\
+	    ("%s: %p not listening", __func__, (sol)));			\
+	mtx_unlock(&(sol)->so_lock);					\
+} while (0)
+#define	SOLISTEN_LOCK_ASSERT(sol)	do {				\
+	mtx_assert(&(sol)->so_lock, MA_OWNED);				\
+	KASSERT(SOLISTENING(sol),					\
+	    ("%s: %p not listening", __func__, (sol)));			\
+} while (0)
 
 /*
  * Externalized form of struct socket used by the sysctl(3) interface.
@@ -212,8 +242,7 @@ struct xsocket {
 
 /* can we read something from so? */
 #define	soreadabledata(so) \
-    (sbavail(&(so)->so_rcv) >= (so)->so_rcv.sb_lowat || \
-	!TAILQ_EMPTY(&(so)->so_comp) || (so)->so_error)
+	(sbavail(&(so)->so_rcv) >= (so)->so_rcv.sb_lowat ||  (so)->so_error)
 #define	soreadable(so) \
 	(soreadabledata(so) || ((so)->so_rcv.sb_state & SBS_CANTRCVMORE))
 
@@ -226,26 +255,19 @@ struct xsocket {
      (so)->so_error)
 
 /*
- * soref()/sorele() ref-count the socket structure.  Note that you must
- * still explicitly close the socket, but the last ref count will free
- * the structure.
+ * soref()/sorele() ref-count the socket structure.
+ * soref() may be called without owning socket lock, but in that case a
+ * caller must own something that holds socket, and so_count must be not 0.
+ * Note that you must still explicitly close the socket, but the last ref
+ * count will free the structure.
  */
-#define	soref(so) do {							\
-	SOCK_LOCK_ASSERT(so);						\
-	++(so)->so_count;						\
-} while (0)
-
+#define	soref(so)	refcount_acquire(&(so)->so_count)
 #define	sorele(so) do {							\
-	ACCEPT_LOCK_ASSERT();						\
 	SOCK_LOCK_ASSERT(so);						\
-	if ((so)->so_count <= 0)					\
-		panic("sorele");					\
-	if (--(so)->so_count == 0)					\
+	if (refcount_release(&(so)->so_count))				\
 		sofree(so);						\
-	else {								\
+	else								\
 		SOCK_UNLOCK(so);					\
-		ACCEPT_UNLOCK();					\
-	}								\
 } while (0)
 
 /*
@@ -370,10 +392,11 @@ void	sohasoutofband(struct socket *so);
 int	solisten(struct socket *so, int backlog, struct thread *td);
 void	solisten_proto(struct socket *so, int backlog);
 int	solisten_proto_check(struct socket *so);
+int	solisten_dequeue(struct socket *, struct socket **, int);
 struct socket *
 	sonewconn(struct socket *head, int connstatus);
-
-
+struct socket *
+	sopeeloff(struct socket *);
 int	sopoll(struct socket *so, int events, struct ucred *active_cred,
 	    struct thread *td);
 int	sopoll_generic(struct socket *so, int events,
@@ -402,15 +425,16 @@ int	sosend_generic(struct socket *so, struct sockaddr *addr,
 	    int flags, struct thread *td);
 int	soshutdown(struct socket *so, int how);
 void	sotoxsocket(struct socket *so, struct xsocket *xso);
-void	soupcall_clear(struct socket *so, int which);
-void	soupcall_set(struct socket *so, int which,
-	    int (*func)(struct socket *, void *, int), void *arg);
+void	soupcall_clear(struct socket *, int);
+void	soupcall_set(struct socket *, int, so_upcall_t, void *);
+void	solisten_upcall_set(struct socket *, so_upcall_t, void *);
 void	sowakeup(struct socket *so, struct sockbuf *sb);
 #ifndef __rtems__
 void	sowakeup_aio(struct socket *so, struct sockbuf *sb);
 #else /* __rtems__ */
 #define	sowakeup_aio(so, sb) (void)0
 #endif /* __rtems__ */
+void	solisten_wakeup(struct socket *);
 int	selsocket(struct socket *so, int events, struct timeval *tv,
 	    struct thread *td);
 
diff --git a/freebsd/sys/sys/sockopt.h b/freebsd/sys/sys/sockopt.h
index 4131a5b7..029e5b4a 100644
--- a/freebsd/sys/sys/sockopt.h
+++ b/freebsd/sys/sys/sockopt.h
@@ -64,8 +64,8 @@ int	sooptcopyout(struct sockopt *sopt, const void *buf, size_t len);
 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	do_getopt_accept_filter(struct socket *so, struct sockopt *sopt);
-int	do_setopt_accept_filter(struct socket *so, struct sockopt *sopt);
+int	accept_filt_getopt(struct socket *, struct sockopt *);
+int	accept_filt_setopt(struct socket *, struct sockopt *);
 int	so_setsockopt(struct socket *so, int level, int optname,
 	    void *optval, size_t optlen);
 
diff --git a/freebsd/sys/sys/sysproto.h b/freebsd/sys/sys/sysproto.h
index 151b380b..d5cda835 100644
--- a/freebsd/sys/sys/sysproto.h
+++ b/freebsd/sys/sys/sysproto.h
@@ -1002,18 +1002,6 @@ struct getresgid_args {
 struct kqueue_args {
 	register_t dummy;
 };
-struct kevent_args {
-	char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)];
-#ifndef __rtems__
-	char changelist_l_[PADL_(struct kevent *)]; struct kevent * changelist; char changelist_r_[PADR_(struct kevent *)];
-#else /* __rtems__ */
-	char changelist_l_[PADL_(struct kevent *)]; const struct kevent * changelist; char changelist_r_[PADR_(struct kevent *)];
-#endif /* __rtems__ */
-	char nchanges_l_[PADL_(int)]; int nchanges; char nchanges_r_[PADR_(int)];
-	char eventlist_l_[PADL_(struct kevent *)]; struct kevent * eventlist; char eventlist_r_[PADR_(struct kevent *)];
-	char nevents_l_[PADL_(int)]; int nevents; char nevents_r_[PADR_(int)];
-	char timeout_l_[PADL_(const struct timespec *)]; const struct timespec * timeout; char timeout_r_[PADR_(const struct timespec *)];
-};
 #ifndef __rtems__
 struct extattr_set_fd_args {
 	char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)];
@@ -1806,6 +1794,20 @@ struct mknodat_args {
 	char mode_l_[PADL_(mode_t)]; mode_t mode; char mode_r_[PADR_(mode_t)];
 	char dev_l_[PADL_(dev_t)]; dev_t dev; char dev_r_[PADR_(dev_t)];
 };
+#endif /* __rtems__ */
+struct kevent_args {
+	char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)];
+#ifndef __rtems__
+	char changelist_l_[PADL_(struct kevent *)]; struct kevent * changelist; char changelist_r_[PADR_(struct kevent *)];
+#else /* __rtems__ */
+	char changelist_l_[PADL_(struct kevent *)]; const struct kevent * changelist; char changelist_r_[PADR_(struct kevent *)];
+#endif /* __rtems__ */
+	char nchanges_l_[PADL_(int)]; int nchanges; char nchanges_r_[PADR_(int)];
+	char eventlist_l_[PADL_(struct kevent *)]; struct kevent * eventlist; char eventlist_r_[PADR_(struct kevent *)];
+	char nevents_l_[PADL_(int)]; int nevents; char nevents_r_[PADR_(int)];
+	char timeout_l_[PADL_(const struct timespec *)]; const struct timespec * timeout; char timeout_r_[PADR_(const struct timespec *)];
+};
+#ifndef __rtems__
 int	nosys(struct thread *, struct nosys_args *);
 void	sys_sys_exit(struct thread *, struct sys_exit_args *);
 int	sys_fork(struct thread *, struct fork_args *);
@@ -2021,7 +2023,6 @@ int	sys_aio_waitcomplete(struct thread *, struct aio_waitcomplete_args *);
 int	sys_getresuid(struct thread *, struct getresuid_args *);
 int	sys_getresgid(struct thread *, struct getresgid_args *);
 int	sys_kqueue(struct thread *, struct kqueue_args *);
-int	sys_kevent(struct thread *, struct kevent_args *);
 int	sys_extattr_set_fd(struct thread *, struct extattr_set_fd_args *);
 int	sys_extattr_get_fd(struct thread *, struct extattr_get_fd_args *);
 int	sys_extattr_delete_fd(struct thread *, struct extattr_delete_fd_args *);
@@ -2186,6 +2187,7 @@ int	sys_fstatfs(struct thread *, struct fstatfs_args *);
 int	sys_getfsstat(struct thread *, struct getfsstat_args *);
 int	sys_fhstatfs(struct thread *, struct fhstatfs_args *);
 int	sys_mknodat(struct thread *, struct mknodat_args *);
+int	sys_kevent(struct thread *, struct kevent_args *);
 
 #ifdef COMPAT_43
 
@@ -2564,6 +2566,14 @@ struct freebsd11_fhstat_args {
 	char u_fhp_l_[PADL_(const struct fhandle *)]; const struct fhandle * u_fhp; char u_fhp_r_[PADR_(const struct fhandle *)];
 	char sb_l_[PADL_(struct freebsd11_stat *)]; struct freebsd11_stat * sb; char sb_r_[PADR_(struct freebsd11_stat *)];
 };
+struct freebsd11_kevent_args {
+	char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)];
+	char changelist_l_[PADL_(struct kevent_freebsd11 *)]; struct kevent_freebsd11 * changelist; char changelist_r_[PADR_(struct kevent_freebsd11 *)];
+	char nchanges_l_[PADL_(int)]; int nchanges; char nchanges_r_[PADR_(int)];
+	char eventlist_l_[PADL_(struct kevent_freebsd11 *)]; struct kevent_freebsd11 * eventlist; char eventlist_r_[PADR_(struct kevent_freebsd11 *)];
+	char nevents_l_[PADL_(int)]; int nevents; char nevents_r_[PADR_(int)];
+	char timeout_l_[PADL_(const struct timespec *)]; const struct timespec * timeout; char timeout_r_[PADR_(const struct timespec *)];
+};
 struct freebsd11_getfsstat_args {
 	char buf_l_[PADL_(struct freebsd11_statfs *)]; struct freebsd11_statfs * buf; char buf_r_[PADR_(struct freebsd11_statfs *)];
 	char bufsize_l_[PADL_(long)]; long bufsize; char bufsize_r_[PADR_(long)];
@@ -2603,6 +2613,7 @@ int	freebsd11_nstat(struct thread *, struct freebsd11_nstat_args *);
 int	freebsd11_nfstat(struct thread *, struct freebsd11_nfstat_args *);
 int	freebsd11_nlstat(struct thread *, struct freebsd11_nlstat_args *);
 int	freebsd11_fhstat(struct thread *, struct freebsd11_fhstat_args *);
+int	freebsd11_kevent(struct thread *, struct freebsd11_kevent_args *);
 int	freebsd11_getfsstat(struct thread *, struct freebsd11_getfsstat_args *);
 int	freebsd11_statfs(struct thread *, struct freebsd11_statfs_args *);
 int	freebsd11_fstatfs(struct thread *, struct freebsd11_fstatfs_args *);
@@ -2897,7 +2908,7 @@ int	freebsd11_mknodat(struct thread *, struct freebsd11_mknodat_args *);
 #define	SYS_AUE_getresuid	AUE_GETRESUID
 #define	SYS_AUE_getresgid	AUE_GETRESGID
 #define	SYS_AUE_kqueue	AUE_KQUEUE
-#define	SYS_AUE_kevent	AUE_KEVENT
+#define	SYS_AUE_freebsd11_kevent	AUE_KEVENT
 #define	SYS_AUE_extattr_set_fd	AUE_EXTATTR_SET_FD
 #define	SYS_AUE_extattr_get_fd	AUE_EXTATTR_GET_FD
 #define	SYS_AUE_extattr_delete_fd	AUE_EXTATTR_DELETE_FD
@@ -3068,6 +3079,7 @@ int	freebsd11_mknodat(struct thread *, struct freebsd11_mknodat_args *);
 #define	SYS_AUE_getfsstat	AUE_GETFSSTAT
 #define	SYS_AUE_fhstatfs	AUE_FHSTATFS
 #define	SYS_AUE_mknodat	AUE_MKNODAT
+#define	SYS_AUE_kevent	AUE_KEVENT
 #endif /* __rtems__ */
 
 #undef PAD_
diff --git a/freebsd/sys/sys/systm.h b/freebsd/sys/sys/systm.h
index 6b557c56..4488c7cd 100644
--- a/freebsd/sys/sys/systm.h
+++ b/freebsd/sys/sys/systm.h
@@ -102,7 +102,7 @@ extern int vm_guest;		/* Running as virtual machine guest? */
  * Keep in sync with vm_guest_sysctl_names[].
  */
 enum VM_GUEST { VM_GUEST_NO = 0, VM_GUEST_VM, VM_GUEST_XEN, VM_GUEST_HV,
-		VM_GUEST_VMWARE, VM_GUEST_KVM, VM_LAST };
+		VM_GUEST_VMWARE, VM_GUEST_KVM, VM_GUEST_BHYVE, VM_LAST };
 
 #if defined(WITNESS) || defined(INVARIANT_SUPPORT)
 #ifndef __rtems__
diff --git a/freebsd/sys/sys/taskqueue.h b/freebsd/sys/sys/taskqueue.h
index 583f796e..7db75c6d 100644
--- a/freebsd/sys/sys/taskqueue.h
+++ b/freebsd/sys/sys/taskqueue.h
@@ -79,6 +79,9 @@ int	taskqueue_start_threads_cpuset(struct taskqueue **tqp, int count,
 int	taskqueue_enqueue(struct taskqueue *queue, struct task *task);
 int	taskqueue_enqueue_timeout(struct taskqueue *queue,
 	    struct timeout_task *timeout_task, int ticks);
+int	taskqueue_enqueue_timeout_sbt(struct taskqueue *queue,
+	    struct timeout_task *timeout_task, sbintime_t sbt, sbintime_t pr,
+	    int flags);
 int	taskqueue_poll_is_busy(struct taskqueue *queue, struct task *task);
 int	taskqueue_cancel(struct taskqueue *queue, struct task *task,
 	    u_int *pendp);
diff --git a/freebsd/sys/sys/unpcb.h b/freebsd/sys/sys/unpcb.h
index 619b68dd..76bc63a9 100644
--- a/freebsd/sys/sys/unpcb.h
+++ b/freebsd/sys/sys/unpcb.h
@@ -96,14 +96,8 @@ struct unpcb {
  * and is really the credentials of the connected peer.  This is used
  * to determine whether the contents should be sent to the user or
  * not.
- *
- * UNP_HAVEPCCACHED - indicates that the unp_peercred member is filled
- * in, but does *not* contain the credentials of the connected peer
- * (there may not even be a peer).  This is set in unp_listen() when
- * it fills in unp_peercred for later consumption by unp_connect().
  */
 #define UNP_HAVEPC			0x001
-#define UNP_HAVEPCCACHED		0x002
 #define	UNP_WANTCRED			0x004	/* credentials wanted */
 #define	UNP_CONNWAIT			0x008	/* connect blocks until accepted */
 
diff --git a/freebsd/sys/sys/uuid.h b/freebsd/sys/sys/uuid.h
index 0748f611..97971fd7 100644
--- a/freebsd/sys/sys/uuid.h
+++ b/freebsd/sys/sys/uuid.h
@@ -65,6 +65,7 @@ int snprintf_uuid(char *, size_t, struct uuid *);
 int printf_uuid(struct uuid *);
 int sbuf_printf_uuid(struct sbuf *, struct uuid *);
 int parse_uuid(const char *, struct uuid *);
+int uuidcmp(const struct uuid *, const struct uuid *);
 
 void be_uuid_dec(void const *buf, struct uuid *uuid);
 void be_uuid_enc(void *buf, struct uuid const *uuid);
diff --git a/freebsd/sys/sys/vnode.h b/freebsd/sys/sys/vnode.h
index 8f123d5e..61cbf000 100644
--- a/freebsd/sys/sys/vnode.h
+++ b/freebsd/sys/sys/vnode.h
@@ -113,14 +113,13 @@ struct vnode {
 
 	/*
 	 * Type specific fields, only one applies to any given vnode.
-	 * See #defines below for renaming to v_* namespace.
 	 */
 	union {
-		struct mount	*vu_mount;	/* v ptr to mountpoint (VDIR) */
-		struct socket	*vu_socket;	/* v unix domain net (VSOCK) */
-		struct cdev	*vu_cdev; 	/* v device (VCHR, VBLK) */
-		struct fifoinfo	*vu_fifoinfo;	/* v fifo (VFIFO) */
-	} v_un;
+		struct mount	*v_mountedhere;	/* v ptr to mountpoint (VDIR) */
+		struct unpcb	*v_unpcb;	/* v unix domain net (VSOCK) */
+		struct cdev	*v_rdev; 	/* v device (VCHR, VBLK) */
+		struct fifoinfo	*v_fifoinfo;	/* v fifo (VFIFO) */
+	};
 
 	/*
 	 * vfs_hash: (mount + inode) -> vnode hash.  The hash value
@@ -176,11 +175,6 @@ struct vnode {
 
 #endif /* defined(_KERNEL) || defined(_KVM_VNODE) */
 
-#define	v_mountedhere	v_un.vu_mount
-#define	v_socket	v_un.vu_socket
-#define	v_rdev		v_un.vu_cdev
-#define	v_fifoinfo	v_un.vu_fifoinfo
-
 #define	bo2vnode(bo)	__containerof((bo), struct vnode, v_bufobj)
 
 /* XXX: These are temporary to avoid a source sweep at this time */
@@ -201,7 +195,7 @@ struct xvnode {
 	long	xv_numoutput;			/* num of writes in progress */
 	enum	vtype xv_type;			/* vnode type */
 	union {
-		void	*xvu_socket;		/* socket, if VSOCK */
+		void	*xvu_socket;		/* unpcb, if VSOCK */
 		void	*xvu_fifo;		/* fifo, if VFIFO */
 		dev_t	xvu_rdev;		/* maj/min, if VBLK/VCHR */
 		struct {
@@ -617,7 +611,7 @@ void	cache_purgevfs(struct mount *mp, bool force);
 int	change_dir(struct vnode *vp, struct thread *td);
 void	cvtstat(struct stat *st, struct ostat *ost);
 void	freebsd11_cvtnstat(struct stat *sb, struct nstat *nsb);
-void	freebsd11_cvtstat(struct stat *st, struct freebsd11_stat *ost);
+int	freebsd11_cvtstat(struct stat *st, struct freebsd11_stat *ost);
 int	getnewvnode(const char *tag, struct mount *mp, struct vop_vector *vops,
 	    struct vnode **vpp);
 void	getnewvnode_reserve(u_int count);