xref: /freebsd/sys/kern/uipc_usrreq.c (revision 8d20be1e22095c27faf8fe8b2f0d089739cc742e)
1 /*-
2  * Copyright (c) 1982, 1986, 1989, 1991, 1993
3  *	The Regents of the University of California.
4  * Copyright (c) 2004-2009 Robert N. M. Watson
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  * 4. Neither the name of the University nor the names of its contributors
16  *    may be used to endorse or promote products derived from this software
17  *    without specific prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29  * SUCH DAMAGE.
30  *
31  *	From: @(#)uipc_usrreq.c	8.3 (Berkeley) 1/4/94
32  */
33 
34 /*
35  * UNIX Domain (Local) Sockets
36  *
37  * This is an implementation of UNIX (local) domain sockets.  Each socket has
38  * an associated struct unpcb (UNIX protocol control block).  Stream sockets
39  * may be connected to 0 or 1 other socket.  Datagram sockets may be
40  * connected to 0, 1, or many other sockets.  Sockets may be created and
41  * connected in pairs (socketpair(2)), or bound/connected to using the file
42  * system name space.  For most purposes, only the receive socket buffer is
43  * used, as sending on one socket delivers directly to the receive socket
44  * buffer of a second socket.
45  *
46  * The implementation is substantially complicated by the fact that
47  * "ancillary data", such as file descriptors or credentials, may be passed
48  * across UNIX domain sockets.  The potential for passing UNIX domain sockets
49  * over other UNIX domain sockets requires the implementation of a simple
50  * garbage collector to find and tear down cycles of disconnected sockets.
51  *
52  * TODO:
53  *	RDM
54  *	distinguish datagram size limits from flow control limits in SEQPACKET
55  *	rethink name space problems
56  *	need a proper out-of-band
57  */
58 
59 #include <sys/cdefs.h>
60 __FBSDID("$FreeBSD$");
61 
62 #include "opt_ddb.h"
63 
64 #include <sys/param.h>
65 #include <sys/capability.h>
66 #include <sys/domain.h>
67 #include <sys/fcntl.h>
68 #include <sys/malloc.h>		/* XXX must be before <sys/file.h> */
69 #include <sys/eventhandler.h>
70 #include <sys/file.h>
71 #include <sys/filedesc.h>
72 #include <sys/kernel.h>
73 #include <sys/lock.h>
74 #include <sys/mbuf.h>
75 #include <sys/mount.h>
76 #include <sys/mutex.h>
77 #include <sys/namei.h>
78 #include <sys/proc.h>
79 #include <sys/protosw.h>
80 #include <sys/queue.h>
81 #include <sys/resourcevar.h>
82 #include <sys/rwlock.h>
83 #include <sys/socket.h>
84 #include <sys/socketvar.h>
85 #include <sys/signalvar.h>
86 #include <sys/stat.h>
87 #include <sys/sx.h>
88 #include <sys/sysctl.h>
89 #include <sys/systm.h>
90 #include <sys/taskqueue.h>
91 #include <sys/un.h>
92 #include <sys/unpcb.h>
93 #include <sys/vnode.h>
94 
95 #include <net/vnet.h>
96 
97 #ifdef DDB
98 #include <ddb/ddb.h>
99 #endif
100 
101 #include <security/mac/mac_framework.h>
102 
103 #include <vm/uma.h>
104 
105 MALLOC_DECLARE(M_FILECAPS);
106 
107 /*
108  * Locking key:
109  * (l)	Locked using list lock
110  * (g)	Locked using linkage lock
111  */
112 
113 static uma_zone_t	unp_zone;
114 static unp_gen_t	unp_gencnt;	/* (l) */
115 static u_int		unp_count;	/* (l) Count of local sockets. */
116 static ino_t		unp_ino;	/* Prototype for fake inode numbers. */
117 static int		unp_rights;	/* (g) File descriptors in flight. */
118 static struct unp_head	unp_shead;	/* (l) List of stream sockets. */
119 static struct unp_head	unp_dhead;	/* (l) List of datagram sockets. */
120 static struct unp_head	unp_sphead;	/* (l) List of seqpacket sockets. */
121 
122 struct unp_defer {
123 	SLIST_ENTRY(unp_defer) ud_link;
124 	struct file *ud_fp;
125 };
126 static SLIST_HEAD(, unp_defer) unp_defers;
127 static int unp_defers_count;
128 
129 static const struct sockaddr	sun_noname = { sizeof(sun_noname), AF_LOCAL };
130 
131 /*
132  * Garbage collection of cyclic file descriptor/socket references occurs
133  * asynchronously in a taskqueue context in order to avoid recursion and
134  * reentrance in the UNIX domain socket, file descriptor, and socket layer
135  * code.  See unp_gc() for a full description.
136  */
137 static struct timeout_task unp_gc_task;
138 
139 /*
140  * The close of unix domain sockets attached as SCM_RIGHTS is
141  * postponed to the taskqueue, to avoid arbitrary recursion depth.
142  * The attached sockets might have another sockets attached.
143  */
144 static struct task	unp_defer_task;
145 
146 /*
147  * Both send and receive buffers are allocated PIPSIZ bytes of buffering for
148  * stream sockets, although the total for sender and receiver is actually
149  * only PIPSIZ.
150  *
151  * Datagram sockets really use the sendspace as the maximum datagram size,
152  * and don't really want to reserve the sendspace.  Their recvspace should be
153  * large enough for at least one max-size datagram plus address.
154  */
155 #ifndef PIPSIZ
156 #define	PIPSIZ	8192
157 #endif
158 static u_long	unpst_sendspace = PIPSIZ;
159 static u_long	unpst_recvspace = PIPSIZ;
160 static u_long	unpdg_sendspace = 2*1024;	/* really max datagram size */
161 static u_long	unpdg_recvspace = 4*1024;
162 static u_long	unpsp_sendspace = PIPSIZ;	/* really max datagram size */
163 static u_long	unpsp_recvspace = PIPSIZ;
164 
165 static SYSCTL_NODE(_net, PF_LOCAL, local, CTLFLAG_RW, 0, "Local domain");
166 static SYSCTL_NODE(_net_local, SOCK_STREAM, stream, CTLFLAG_RW, 0,
167     "SOCK_STREAM");
168 static SYSCTL_NODE(_net_local, SOCK_DGRAM, dgram, CTLFLAG_RW, 0, "SOCK_DGRAM");
169 static SYSCTL_NODE(_net_local, SOCK_SEQPACKET, seqpacket, CTLFLAG_RW, 0,
170     "SOCK_SEQPACKET");
171 
172 SYSCTL_ULONG(_net_local_stream, OID_AUTO, sendspace, CTLFLAG_RW,
173 	   &unpst_sendspace, 0, "Default stream send space.");
174 SYSCTL_ULONG(_net_local_stream, OID_AUTO, recvspace, CTLFLAG_RW,
175 	   &unpst_recvspace, 0, "Default stream receive space.");
176 SYSCTL_ULONG(_net_local_dgram, OID_AUTO, maxdgram, CTLFLAG_RW,
177 	   &unpdg_sendspace, 0, "Default datagram send space.");
178 SYSCTL_ULONG(_net_local_dgram, OID_AUTO, recvspace, CTLFLAG_RW,
179 	   &unpdg_recvspace, 0, "Default datagram receive space.");
180 SYSCTL_ULONG(_net_local_seqpacket, OID_AUTO, maxseqpacket, CTLFLAG_RW,
181 	   &unpsp_sendspace, 0, "Default seqpacket send space.");
182 SYSCTL_ULONG(_net_local_seqpacket, OID_AUTO, recvspace, CTLFLAG_RW,
183 	   &unpsp_recvspace, 0, "Default seqpacket receive space.");
184 SYSCTL_INT(_net_local, OID_AUTO, inflight, CTLFLAG_RD, &unp_rights, 0,
185     "File descriptors in flight.");
186 SYSCTL_INT(_net_local, OID_AUTO, deferred, CTLFLAG_RD,
187     &unp_defers_count, 0,
188     "File descriptors deferred to taskqueue for close.");
189 
190 /*
191  * Locking and synchronization:
192  *
193  * Three types of locks exit in the local domain socket implementation: a
194  * global list mutex, a global linkage rwlock, and per-unpcb mutexes.  Of the
195  * global locks, the list lock protects the socket count, global generation
196  * number, and stream/datagram global lists.  The linkage lock protects the
197  * interconnection of unpcbs, the v_socket and unp_vnode pointers, and can be
198  * held exclusively over the acquisition of multiple unpcb locks to prevent
199  * deadlock.
200  *
201  * UNIX domain sockets each have an unpcb hung off of their so_pcb pointer,
202  * allocated in pru_attach() and freed in pru_detach().  The validity of that
203  * pointer is an invariant, so no lock is required to dereference the so_pcb
204  * pointer if a valid socket reference is held by the caller.  In practice,
205  * this is always true during operations performed on a socket.  Each unpcb
206  * has a back-pointer to its socket, unp_socket, which will be stable under
207  * the same circumstances.
208  *
209  * This pointer may only be safely dereferenced as long as a valid reference
210  * to the unpcb is held.  Typically, this reference will be from the socket,
211  * or from another unpcb when the referring unpcb's lock is held (in order
212  * that the reference not be invalidated during use).  For example, to follow
213  * unp->unp_conn->unp_socket, you need unlock the lock on unp, not unp_conn,
214  * as unp_socket remains valid as long as the reference to unp_conn is valid.
215  *
216  * Fields of unpcbss are locked using a per-unpcb lock, unp_mtx.  Individual
217  * atomic reads without the lock may be performed "lockless", but more
218  * complex reads and read-modify-writes require the mutex to be held.  No
219  * lock order is defined between unpcb locks -- multiple unpcb locks may be
220  * acquired at the same time only when holding the linkage rwlock
221  * exclusively, which prevents deadlocks.
222  *
223  * Blocking with UNIX domain sockets is a tricky issue: unlike most network
224  * protocols, bind() is a non-atomic operation, and connect() requires
225  * potential sleeping in the protocol, due to potentially waiting on local or
226  * distributed file systems.  We try to separate "lookup" operations, which
227  * may sleep, and the IPC operations themselves, which typically can occur
228  * with relative atomicity as locks can be held over the entire operation.
229  *
230  * Another tricky issue is simultaneous multi-threaded or multi-process
231  * access to a single UNIX domain socket.  These are handled by the flags
232  * UNP_CONNECTING and UNP_BINDING, which prevent concurrent connecting or
233  * binding, both of which involve dropping UNIX domain socket locks in order
234  * to perform namei() and other file system operations.
235  */
236 static struct rwlock	unp_link_rwlock;
237 static struct mtx	unp_list_lock;
238 static struct mtx	unp_defers_lock;
239 
240 #define	UNP_LINK_LOCK_INIT()		rw_init(&unp_link_rwlock,	\
241 					    "unp_link_rwlock")
242 
243 #define	UNP_LINK_LOCK_ASSERT()	rw_assert(&unp_link_rwlock,	\
244 					    RA_LOCKED)
245 #define	UNP_LINK_UNLOCK_ASSERT()	rw_assert(&unp_link_rwlock,	\
246 					    RA_UNLOCKED)
247 
248 #define	UNP_LINK_RLOCK()		rw_rlock(&unp_link_rwlock)
249 #define	UNP_LINK_RUNLOCK()		rw_runlock(&unp_link_rwlock)
250 #define	UNP_LINK_WLOCK()		rw_wlock(&unp_link_rwlock)
251 #define	UNP_LINK_WUNLOCK()		rw_wunlock(&unp_link_rwlock)
252 #define	UNP_LINK_WLOCK_ASSERT()		rw_assert(&unp_link_rwlock,	\
253 					    RA_WLOCKED)
254 
255 #define	UNP_LIST_LOCK_INIT()		mtx_init(&unp_list_lock,	\
256 					    "unp_list_lock", NULL, MTX_DEF)
257 #define	UNP_LIST_LOCK()			mtx_lock(&unp_list_lock)
258 #define	UNP_LIST_UNLOCK()		mtx_unlock(&unp_list_lock)
259 
260 #define	UNP_DEFERRED_LOCK_INIT()	mtx_init(&unp_defers_lock, \
261 					    "unp_defer", NULL, MTX_DEF)
262 #define	UNP_DEFERRED_LOCK()		mtx_lock(&unp_defers_lock)
263 #define	UNP_DEFERRED_UNLOCK()		mtx_unlock(&unp_defers_lock)
264 
265 #define UNP_PCB_LOCK_INIT(unp)		mtx_init(&(unp)->unp_mtx,	\
266 					    "unp_mtx", "unp_mtx",	\
267 					    MTX_DUPOK|MTX_DEF|MTX_RECURSE)
268 #define	UNP_PCB_LOCK_DESTROY(unp)	mtx_destroy(&(unp)->unp_mtx)
269 #define	UNP_PCB_LOCK(unp)		mtx_lock(&(unp)->unp_mtx)
270 #define	UNP_PCB_UNLOCK(unp)		mtx_unlock(&(unp)->unp_mtx)
271 #define	UNP_PCB_LOCK_ASSERT(unp)	mtx_assert(&(unp)->unp_mtx, MA_OWNED)
272 
273 static int	uipc_connect2(struct socket *, struct socket *);
274 static int	uipc_ctloutput(struct socket *, struct sockopt *);
275 static int	unp_connect(struct socket *, struct sockaddr *,
276 		    struct thread *);
277 static int	unp_connectat(int, struct socket *, struct sockaddr *,
278 		    struct thread *);
279 static int	unp_connect2(struct socket *so, struct socket *so2, int);
280 static void	unp_disconnect(struct unpcb *unp, struct unpcb *unp2);
281 static void	unp_dispose(struct mbuf *);
282 static void	unp_shutdown(struct unpcb *);
283 static void	unp_drop(struct unpcb *, int);
284 static void	unp_gc(__unused void *, int);
285 static void	unp_scan(struct mbuf *, void (*)(struct filedescent **, int));
286 static void	unp_discard(struct file *);
287 static void	unp_freerights(struct filedescent **, int);
288 static void	unp_init(void);
289 static int	unp_internalize(struct mbuf **, struct thread *);
290 static void	unp_internalize_fp(struct file *);
291 static int	unp_externalize(struct mbuf *, struct mbuf **, int);
292 static int	unp_externalize_fp(struct file *);
293 static struct mbuf	*unp_addsockcred(struct thread *, struct mbuf *);
294 static void	unp_process_defers(void * __unused, int);
295 
296 /*
297  * Definitions of protocols supported in the LOCAL domain.
298  */
299 static struct domain localdomain;
300 static struct pr_usrreqs uipc_usrreqs_dgram, uipc_usrreqs_stream;
301 static struct pr_usrreqs uipc_usrreqs_seqpacket;
302 static struct protosw localsw[] = {
303 {
304 	.pr_type =		SOCK_STREAM,
305 	.pr_domain =		&localdomain,
306 	.pr_flags =		PR_CONNREQUIRED|PR_WANTRCVD|PR_RIGHTS,
307 	.pr_ctloutput =		&uipc_ctloutput,
308 	.pr_usrreqs =		&uipc_usrreqs_stream
309 },
310 {
311 	.pr_type =		SOCK_DGRAM,
312 	.pr_domain =		&localdomain,
313 	.pr_flags =		PR_ATOMIC|PR_ADDR|PR_RIGHTS,
314 	.pr_ctloutput =		&uipc_ctloutput,
315 	.pr_usrreqs =		&uipc_usrreqs_dgram
316 },
317 {
318 	.pr_type =		SOCK_SEQPACKET,
319 	.pr_domain =		&localdomain,
320 
321 	/*
322 	 * XXXRW: For now, PR_ADDR because soreceive will bump into them
323 	 * due to our use of sbappendaddr.  A new sbappend variants is needed
324 	 * that supports both atomic record writes and control data.
325 	 */
326 	.pr_flags =		PR_ADDR|PR_ATOMIC|PR_CONNREQUIRED|PR_WANTRCVD|
327 				    PR_RIGHTS,
328 	.pr_ctloutput =		&uipc_ctloutput,
329 	.pr_usrreqs =		&uipc_usrreqs_seqpacket,
330 },
331 };
332 
333 static struct domain localdomain = {
334 	.dom_family =		AF_LOCAL,
335 	.dom_name =		"local",
336 	.dom_init =		unp_init,
337 	.dom_externalize =	unp_externalize,
338 	.dom_dispose =		unp_dispose,
339 	.dom_protosw =		localsw,
340 	.dom_protoswNPROTOSW =	&localsw[sizeof(localsw)/sizeof(localsw[0])]
341 };
342 DOMAIN_SET(local);
343 
344 static void
345 uipc_abort(struct socket *so)
346 {
347 	struct unpcb *unp, *unp2;
348 
349 	unp = sotounpcb(so);
350 	KASSERT(unp != NULL, ("uipc_abort: unp == NULL"));
351 
352 	UNP_LINK_WLOCK();
353 	UNP_PCB_LOCK(unp);
354 	unp2 = unp->unp_conn;
355 	if (unp2 != NULL) {
356 		UNP_PCB_LOCK(unp2);
357 		unp_drop(unp2, ECONNABORTED);
358 		UNP_PCB_UNLOCK(unp2);
359 	}
360 	UNP_PCB_UNLOCK(unp);
361 	UNP_LINK_WUNLOCK();
362 }
363 
364 static int
365 uipc_accept(struct socket *so, struct sockaddr **nam)
366 {
367 	struct unpcb *unp, *unp2;
368 	const struct sockaddr *sa;
369 
370 	/*
371 	 * Pass back name of connected socket, if it was bound and we are
372 	 * still connected (our peer may have closed already!).
373 	 */
374 	unp = sotounpcb(so);
375 	KASSERT(unp != NULL, ("uipc_accept: unp == NULL"));
376 
377 	*nam = malloc(sizeof(struct sockaddr_un), M_SONAME, M_WAITOK);
378 	UNP_LINK_RLOCK();
379 	unp2 = unp->unp_conn;
380 	if (unp2 != NULL && unp2->unp_addr != NULL) {
381 		UNP_PCB_LOCK(unp2);
382 		sa = (struct sockaddr *) unp2->unp_addr;
383 		bcopy(sa, *nam, sa->sa_len);
384 		UNP_PCB_UNLOCK(unp2);
385 	} else {
386 		sa = &sun_noname;
387 		bcopy(sa, *nam, sa->sa_len);
388 	}
389 	UNP_LINK_RUNLOCK();
390 	return (0);
391 }
392 
393 static int
394 uipc_attach(struct socket *so, int proto, struct thread *td)
395 {
396 	u_long sendspace, recvspace;
397 	struct unpcb *unp;
398 	int error;
399 
400 	KASSERT(so->so_pcb == NULL, ("uipc_attach: so_pcb != NULL"));
401 	if (so->so_snd.sb_hiwat == 0 || so->so_rcv.sb_hiwat == 0) {
402 		switch (so->so_type) {
403 		case SOCK_STREAM:
404 			sendspace = unpst_sendspace;
405 			recvspace = unpst_recvspace;
406 			break;
407 
408 		case SOCK_DGRAM:
409 			sendspace = unpdg_sendspace;
410 			recvspace = unpdg_recvspace;
411 			break;
412 
413 		case SOCK_SEQPACKET:
414 			sendspace = unpsp_sendspace;
415 			recvspace = unpsp_recvspace;
416 			break;
417 
418 		default:
419 			panic("uipc_attach");
420 		}
421 		error = soreserve(so, sendspace, recvspace);
422 		if (error)
423 			return (error);
424 	}
425 	unp = uma_zalloc(unp_zone, M_NOWAIT | M_ZERO);
426 	if (unp == NULL)
427 		return (ENOBUFS);
428 	LIST_INIT(&unp->unp_refs);
429 	UNP_PCB_LOCK_INIT(unp);
430 	unp->unp_socket = so;
431 	so->so_pcb = unp;
432 	unp->unp_refcount = 1;
433 
434 	UNP_LIST_LOCK();
435 	unp->unp_gencnt = ++unp_gencnt;
436 	unp_count++;
437 	switch (so->so_type) {
438 	case SOCK_STREAM:
439 		LIST_INSERT_HEAD(&unp_shead, unp, unp_link);
440 		break;
441 
442 	case SOCK_DGRAM:
443 		LIST_INSERT_HEAD(&unp_dhead, unp, unp_link);
444 		break;
445 
446 	case SOCK_SEQPACKET:
447 		LIST_INSERT_HEAD(&unp_sphead, unp, unp_link);
448 		break;
449 
450 	default:
451 		panic("uipc_attach");
452 	}
453 	UNP_LIST_UNLOCK();
454 
455 	return (0);
456 }
457 
458 static int
459 uipc_bindat(int fd, struct socket *so, struct sockaddr *nam, struct thread *td)
460 {
461 	struct sockaddr_un *soun = (struct sockaddr_un *)nam;
462 	struct vattr vattr;
463 	int error, namelen;
464 	struct nameidata nd;
465 	struct unpcb *unp;
466 	struct vnode *vp;
467 	struct mount *mp;
468 	cap_rights_t rights;
469 	char *buf;
470 
471 	unp = sotounpcb(so);
472 	KASSERT(unp != NULL, ("uipc_bind: unp == NULL"));
473 
474 	if (soun->sun_len > sizeof(struct sockaddr_un))
475 		return (EINVAL);
476 	namelen = soun->sun_len - offsetof(struct sockaddr_un, sun_path);
477 	if (namelen <= 0)
478 		return (EINVAL);
479 
480 	/*
481 	 * We don't allow simultaneous bind() calls on a single UNIX domain
482 	 * socket, so flag in-progress operations, and return an error if an
483 	 * operation is already in progress.
484 	 *
485 	 * Historically, we have not allowed a socket to be rebound, so this
486 	 * also returns an error.  Not allowing re-binding simplifies the
487 	 * implementation and avoids a great many possible failure modes.
488 	 */
489 	UNP_PCB_LOCK(unp);
490 	if (unp->unp_vnode != NULL) {
491 		UNP_PCB_UNLOCK(unp);
492 		return (EINVAL);
493 	}
494 	if (unp->unp_flags & UNP_BINDING) {
495 		UNP_PCB_UNLOCK(unp);
496 		return (EALREADY);
497 	}
498 	unp->unp_flags |= UNP_BINDING;
499 	UNP_PCB_UNLOCK(unp);
500 
501 	buf = malloc(namelen + 1, M_TEMP, M_WAITOK);
502 	bcopy(soun->sun_path, buf, namelen);
503 	buf[namelen] = 0;
504 
505 restart:
506 	NDINIT_ATRIGHTS(&nd, CREATE, NOFOLLOW | LOCKPARENT | SAVENAME,
507 	    UIO_SYSSPACE, buf, fd, cap_rights_init(&rights, CAP_BINDAT), td);
508 /* SHOULD BE ABLE TO ADOPT EXISTING AND wakeup() ALA FIFO's */
509 	error = namei(&nd);
510 	if (error)
511 		goto error;
512 	vp = nd.ni_vp;
513 	if (vp != NULL || vn_start_write(nd.ni_dvp, &mp, V_NOWAIT) != 0) {
514 		NDFREE(&nd, NDF_ONLY_PNBUF);
515 		if (nd.ni_dvp == vp)
516 			vrele(nd.ni_dvp);
517 		else
518 			vput(nd.ni_dvp);
519 		if (vp != NULL) {
520 			vrele(vp);
521 			error = EADDRINUSE;
522 			goto error;
523 		}
524 		error = vn_start_write(NULL, &mp, V_XSLEEP | PCATCH);
525 		if (error)
526 			goto error;
527 		goto restart;
528 	}
529 	VATTR_NULL(&vattr);
530 	vattr.va_type = VSOCK;
531 	vattr.va_mode = (ACCESSPERMS & ~td->td_proc->p_fd->fd_cmask);
532 #ifdef MAC
533 	error = mac_vnode_check_create(td->td_ucred, nd.ni_dvp, &nd.ni_cnd,
534 	    &vattr);
535 #endif
536 	if (error == 0)
537 		error = VOP_CREATE(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr);
538 	NDFREE(&nd, NDF_ONLY_PNBUF);
539 	vput(nd.ni_dvp);
540 	if (error) {
541 		vn_finished_write(mp);
542 		goto error;
543 	}
544 	vp = nd.ni_vp;
545 	ASSERT_VOP_ELOCKED(vp, "uipc_bind");
546 	soun = (struct sockaddr_un *)sodupsockaddr(nam, M_WAITOK);
547 
548 	UNP_LINK_WLOCK();
549 	UNP_PCB_LOCK(unp);
550 	VOP_UNP_BIND(vp, unp->unp_socket);
551 	unp->unp_vnode = vp;
552 	unp->unp_addr = soun;
553 	unp->unp_flags &= ~UNP_BINDING;
554 	UNP_PCB_UNLOCK(unp);
555 	UNP_LINK_WUNLOCK();
556 	VOP_UNLOCK(vp, 0);
557 	vn_finished_write(mp);
558 	free(buf, M_TEMP);
559 	return (0);
560 
561 error:
562 	UNP_PCB_LOCK(unp);
563 	unp->unp_flags &= ~UNP_BINDING;
564 	UNP_PCB_UNLOCK(unp);
565 	free(buf, M_TEMP);
566 	return (error);
567 }
568 
569 static int
570 uipc_bind(struct socket *so, struct sockaddr *nam, struct thread *td)
571 {
572 
573 	return (uipc_bindat(AT_FDCWD, so, nam, td));
574 }
575 
576 static int
577 uipc_connect(struct socket *so, struct sockaddr *nam, struct thread *td)
578 {
579 	int error;
580 
581 	KASSERT(td == curthread, ("uipc_connect: td != curthread"));
582 	UNP_LINK_WLOCK();
583 	error = unp_connect(so, nam, td);
584 	UNP_LINK_WUNLOCK();
585 	return (error);
586 }
587 
588 static int
589 uipc_connectat(int fd, struct socket *so, struct sockaddr *nam,
590     struct thread *td)
591 {
592 	int error;
593 
594 	KASSERT(td == curthread, ("uipc_connectat: td != curthread"));
595 	UNP_LINK_WLOCK();
596 	error = unp_connectat(fd, so, nam, td);
597 	UNP_LINK_WUNLOCK();
598 	return (error);
599 }
600 
601 static void
602 uipc_close(struct socket *so)
603 {
604 	struct unpcb *unp, *unp2;
605 
606 	unp = sotounpcb(so);
607 	KASSERT(unp != NULL, ("uipc_close: unp == NULL"));
608 
609 	UNP_LINK_WLOCK();
610 	UNP_PCB_LOCK(unp);
611 	unp2 = unp->unp_conn;
612 	if (unp2 != NULL) {
613 		UNP_PCB_LOCK(unp2);
614 		unp_disconnect(unp, unp2);
615 		UNP_PCB_UNLOCK(unp2);
616 	}
617 	UNP_PCB_UNLOCK(unp);
618 	UNP_LINK_WUNLOCK();
619 }
620 
621 static int
622 uipc_connect2(struct socket *so1, struct socket *so2)
623 {
624 	struct unpcb *unp, *unp2;
625 	int error;
626 
627 	UNP_LINK_WLOCK();
628 	unp = so1->so_pcb;
629 	KASSERT(unp != NULL, ("uipc_connect2: unp == NULL"));
630 	UNP_PCB_LOCK(unp);
631 	unp2 = so2->so_pcb;
632 	KASSERT(unp2 != NULL, ("uipc_connect2: unp2 == NULL"));
633 	UNP_PCB_LOCK(unp2);
634 	error = unp_connect2(so1, so2, PRU_CONNECT2);
635 	UNP_PCB_UNLOCK(unp2);
636 	UNP_PCB_UNLOCK(unp);
637 	UNP_LINK_WUNLOCK();
638 	return (error);
639 }
640 
641 static void
642 uipc_detach(struct socket *so)
643 {
644 	struct unpcb *unp, *unp2;
645 	struct sockaddr_un *saved_unp_addr;
646 	struct vnode *vp;
647 	int freeunp, local_unp_rights;
648 
649 	unp = sotounpcb(so);
650 	KASSERT(unp != NULL, ("uipc_detach: unp == NULL"));
651 
652 	UNP_LINK_WLOCK();
653 	UNP_LIST_LOCK();
654 	UNP_PCB_LOCK(unp);
655 	LIST_REMOVE(unp, unp_link);
656 	unp->unp_gencnt = ++unp_gencnt;
657 	--unp_count;
658 	UNP_LIST_UNLOCK();
659 
660 	/*
661 	 * XXXRW: Should assert vp->v_socket == so.
662 	 */
663 	if ((vp = unp->unp_vnode) != NULL) {
664 		VOP_UNP_DETACH(vp);
665 		unp->unp_vnode = NULL;
666 	}
667 	unp2 = unp->unp_conn;
668 	if (unp2 != NULL) {
669 		UNP_PCB_LOCK(unp2);
670 		unp_disconnect(unp, unp2);
671 		UNP_PCB_UNLOCK(unp2);
672 	}
673 
674 	/*
675 	 * We hold the linkage lock exclusively, so it's OK to acquire
676 	 * multiple pcb locks at a time.
677 	 */
678 	while (!LIST_EMPTY(&unp->unp_refs)) {
679 		struct unpcb *ref = LIST_FIRST(&unp->unp_refs);
680 
681 		UNP_PCB_LOCK(ref);
682 		unp_drop(ref, ECONNRESET);
683 		UNP_PCB_UNLOCK(ref);
684 	}
685 	local_unp_rights = unp_rights;
686 	UNP_LINK_WUNLOCK();
687 	unp->unp_socket->so_pcb = NULL;
688 	saved_unp_addr = unp->unp_addr;
689 	unp->unp_addr = NULL;
690 	unp->unp_refcount--;
691 	freeunp = (unp->unp_refcount == 0);
692 	if (saved_unp_addr != NULL)
693 		free(saved_unp_addr, M_SONAME);
694 	if (freeunp) {
695 		UNP_PCB_LOCK_DESTROY(unp);
696 		uma_zfree(unp_zone, unp);
697 	} else
698 		UNP_PCB_UNLOCK(unp);
699 	if (vp)
700 		vrele(vp);
701 	if (local_unp_rights)
702 		taskqueue_enqueue_timeout(taskqueue_thread, &unp_gc_task, -1);
703 }
704 
705 static int
706 uipc_disconnect(struct socket *so)
707 {
708 	struct unpcb *unp, *unp2;
709 
710 	unp = sotounpcb(so);
711 	KASSERT(unp != NULL, ("uipc_disconnect: unp == NULL"));
712 
713 	UNP_LINK_WLOCK();
714 	UNP_PCB_LOCK(unp);
715 	unp2 = unp->unp_conn;
716 	if (unp2 != NULL) {
717 		UNP_PCB_LOCK(unp2);
718 		unp_disconnect(unp, unp2);
719 		UNP_PCB_UNLOCK(unp2);
720 	}
721 	UNP_PCB_UNLOCK(unp);
722 	UNP_LINK_WUNLOCK();
723 	return (0);
724 }
725 
726 static int
727 uipc_listen(struct socket *so, int backlog, struct thread *td)
728 {
729 	struct unpcb *unp;
730 	int error;
731 
732 	unp = sotounpcb(so);
733 	KASSERT(unp != NULL, ("uipc_listen: unp == NULL"));
734 
735 	UNP_PCB_LOCK(unp);
736 	if (unp->unp_vnode == NULL) {
737 		UNP_PCB_UNLOCK(unp);
738 		return (EINVAL);
739 	}
740 
741 	SOCK_LOCK(so);
742 	error = solisten_proto_check(so);
743 	if (error == 0) {
744 		cru2x(td->td_ucred, &unp->unp_peercred);
745 		unp->unp_flags |= UNP_HAVEPCCACHED;
746 		solisten_proto(so, backlog);
747 	}
748 	SOCK_UNLOCK(so);
749 	UNP_PCB_UNLOCK(unp);
750 	return (error);
751 }
752 
753 static int
754 uipc_peeraddr(struct socket *so, struct sockaddr **nam)
755 {
756 	struct unpcb *unp, *unp2;
757 	const struct sockaddr *sa;
758 
759 	unp = sotounpcb(so);
760 	KASSERT(unp != NULL, ("uipc_peeraddr: unp == NULL"));
761 
762 	*nam = malloc(sizeof(struct sockaddr_un), M_SONAME, M_WAITOK);
763 	UNP_LINK_RLOCK();
764 	/*
765 	 * XXX: It seems that this test always fails even when connection is
766 	 * established.  So, this else clause is added as workaround to
767 	 * return PF_LOCAL sockaddr.
768 	 */
769 	unp2 = unp->unp_conn;
770 	if (unp2 != NULL) {
771 		UNP_PCB_LOCK(unp2);
772 		if (unp2->unp_addr != NULL)
773 			sa = (struct sockaddr *) unp2->unp_addr;
774 		else
775 			sa = &sun_noname;
776 		bcopy(sa, *nam, sa->sa_len);
777 		UNP_PCB_UNLOCK(unp2);
778 	} else {
779 		sa = &sun_noname;
780 		bcopy(sa, *nam, sa->sa_len);
781 	}
782 	UNP_LINK_RUNLOCK();
783 	return (0);
784 }
785 
786 static int
787 uipc_rcvd(struct socket *so, int flags)
788 {
789 	struct unpcb *unp, *unp2;
790 	struct socket *so2;
791 	u_int mbcnt, sbcc;
792 	u_long newhiwat;
793 
794 	unp = sotounpcb(so);
795 	KASSERT(unp != NULL, ("uipc_rcvd: unp == NULL"));
796 
797 	if (so->so_type != SOCK_STREAM && so->so_type != SOCK_SEQPACKET)
798 		panic("uipc_rcvd socktype %d", so->so_type);
799 
800 	/*
801 	 * Adjust backpressure on sender and wakeup any waiting to write.
802 	 *
803 	 * The unp lock is acquired to maintain the validity of the unp_conn
804 	 * pointer; no lock on unp2 is required as unp2->unp_socket will be
805 	 * static as long as we don't permit unp2 to disconnect from unp,
806 	 * which is prevented by the lock on unp.  We cache values from
807 	 * so_rcv to avoid holding the so_rcv lock over the entire
808 	 * transaction on the remote so_snd.
809 	 */
810 	SOCKBUF_LOCK(&so->so_rcv);
811 	mbcnt = so->so_rcv.sb_mbcnt;
812 	sbcc = so->so_rcv.sb_cc;
813 	SOCKBUF_UNLOCK(&so->so_rcv);
814 	UNP_PCB_LOCK(unp);
815 	unp2 = unp->unp_conn;
816 	if (unp2 == NULL) {
817 		UNP_PCB_UNLOCK(unp);
818 		return (0);
819 	}
820 	so2 = unp2->unp_socket;
821 	SOCKBUF_LOCK(&so2->so_snd);
822 	so2->so_snd.sb_mbmax += unp->unp_mbcnt - mbcnt;
823 	newhiwat = so2->so_snd.sb_hiwat + unp->unp_cc - sbcc;
824 	(void)chgsbsize(so2->so_cred->cr_uidinfo, &so2->so_snd.sb_hiwat,
825 	    newhiwat, RLIM_INFINITY);
826 	sowwakeup_locked(so2);
827 	unp->unp_mbcnt = mbcnt;
828 	unp->unp_cc = sbcc;
829 	UNP_PCB_UNLOCK(unp);
830 	return (0);
831 }
832 
833 static int
834 uipc_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *nam,
835     struct mbuf *control, struct thread *td)
836 {
837 	struct unpcb *unp, *unp2;
838 	struct socket *so2;
839 	u_int mbcnt_delta, sbcc;
840 	u_int newhiwat;
841 	int error = 0;
842 
843 	unp = sotounpcb(so);
844 	KASSERT(unp != NULL, ("uipc_send: unp == NULL"));
845 
846 	if (flags & PRUS_OOB) {
847 		error = EOPNOTSUPP;
848 		goto release;
849 	}
850 	if (control != NULL && (error = unp_internalize(&control, td)))
851 		goto release;
852 	if ((nam != NULL) || (flags & PRUS_EOF))
853 		UNP_LINK_WLOCK();
854 	else
855 		UNP_LINK_RLOCK();
856 	switch (so->so_type) {
857 	case SOCK_DGRAM:
858 	{
859 		const struct sockaddr *from;
860 
861 		unp2 = unp->unp_conn;
862 		if (nam != NULL) {
863 			UNP_LINK_WLOCK_ASSERT();
864 			if (unp2 != NULL) {
865 				error = EISCONN;
866 				break;
867 			}
868 			error = unp_connect(so, nam, td);
869 			if (error)
870 				break;
871 			unp2 = unp->unp_conn;
872 		}
873 
874 		/*
875 		 * Because connect() and send() are non-atomic in a sendto()
876 		 * with a target address, it's possible that the socket will
877 		 * have disconnected before the send() can run.  In that case
878 		 * return the slightly counter-intuitive but otherwise
879 		 * correct error that the socket is not connected.
880 		 */
881 		if (unp2 == NULL) {
882 			error = ENOTCONN;
883 			break;
884 		}
885 		/* Lockless read. */
886 		if (unp2->unp_flags & UNP_WANTCRED)
887 			control = unp_addsockcred(td, control);
888 		UNP_PCB_LOCK(unp);
889 		if (unp->unp_addr != NULL)
890 			from = (struct sockaddr *)unp->unp_addr;
891 		else
892 			from = &sun_noname;
893 		so2 = unp2->unp_socket;
894 		SOCKBUF_LOCK(&so2->so_rcv);
895 		if (sbappendaddr_locked(&so2->so_rcv, from, m, control)) {
896 			sorwakeup_locked(so2);
897 			m = NULL;
898 			control = NULL;
899 		} else {
900 			SOCKBUF_UNLOCK(&so2->so_rcv);
901 			error = ENOBUFS;
902 		}
903 		if (nam != NULL) {
904 			UNP_LINK_WLOCK_ASSERT();
905 			UNP_PCB_LOCK(unp2);
906 			unp_disconnect(unp, unp2);
907 			UNP_PCB_UNLOCK(unp2);
908 		}
909 		UNP_PCB_UNLOCK(unp);
910 		break;
911 	}
912 
913 	case SOCK_SEQPACKET:
914 	case SOCK_STREAM:
915 		if ((so->so_state & SS_ISCONNECTED) == 0) {
916 			if (nam != NULL) {
917 				UNP_LINK_WLOCK_ASSERT();
918 				error = unp_connect(so, nam, td);
919 				if (error)
920 					break;	/* XXX */
921 			} else {
922 				error = ENOTCONN;
923 				break;
924 			}
925 		}
926 
927 		/* Lockless read. */
928 		if (so->so_snd.sb_state & SBS_CANTSENDMORE) {
929 			error = EPIPE;
930 			break;
931 		}
932 
933 		/*
934 		 * Because connect() and send() are non-atomic in a sendto()
935 		 * with a target address, it's possible that the socket will
936 		 * have disconnected before the send() can run.  In that case
937 		 * return the slightly counter-intuitive but otherwise
938 		 * correct error that the socket is not connected.
939 		 *
940 		 * Locking here must be done carefully: the linkage lock
941 		 * prevents interconnections between unpcbs from changing, so
942 		 * we can traverse from unp to unp2 without acquiring unp's
943 		 * lock.  Socket buffer locks follow unpcb locks, so we can
944 		 * acquire both remote and lock socket buffer locks.
945 		 */
946 		unp2 = unp->unp_conn;
947 		if (unp2 == NULL) {
948 			error = ENOTCONN;
949 			break;
950 		}
951 		so2 = unp2->unp_socket;
952 		UNP_PCB_LOCK(unp2);
953 		SOCKBUF_LOCK(&so2->so_rcv);
954 		if (unp2->unp_flags & UNP_WANTCRED) {
955 			/*
956 			 * Credentials are passed only once on SOCK_STREAM
957 			 * and SOCK_SEQPACKET.
958 			 */
959 			unp2->unp_flags &= ~UNP_WANTCRED;
960 			control = unp_addsockcred(td, control);
961 		}
962 		/*
963 		 * Send to paired receive port, and then reduce send buffer
964 		 * hiwater marks to maintain backpressure.  Wake up readers.
965 		 */
966 		switch (so->so_type) {
967 		case SOCK_STREAM:
968 			if (control != NULL) {
969 				if (sbappendcontrol_locked(&so2->so_rcv, m,
970 				    control))
971 					control = NULL;
972 			} else
973 				sbappend_locked(&so2->so_rcv, m);
974 			break;
975 
976 		case SOCK_SEQPACKET: {
977 			const struct sockaddr *from;
978 
979 			from = &sun_noname;
980 			if (sbappendaddr_locked(&so2->so_rcv, from, m,
981 			    control))
982 				control = NULL;
983 			break;
984 			}
985 		}
986 
987 		/*
988 		 * XXXRW: While fine for SOCK_STREAM, this conflates maximum
989 		 * datagram size and back-pressure for SOCK_SEQPACKET, which
990 		 * can lead to undesired return of EMSGSIZE on send instead
991 		 * of more desirable blocking.
992 		 */
993 		mbcnt_delta = so2->so_rcv.sb_mbcnt - unp2->unp_mbcnt;
994 		unp2->unp_mbcnt = so2->so_rcv.sb_mbcnt;
995 		sbcc = so2->so_rcv.sb_cc;
996 		sorwakeup_locked(so2);
997 
998 		SOCKBUF_LOCK(&so->so_snd);
999 		if ((int)so->so_snd.sb_hiwat >= (int)(sbcc - unp2->unp_cc))
1000 			newhiwat = so->so_snd.sb_hiwat - (sbcc - unp2->unp_cc);
1001 		else
1002 			newhiwat = 0;
1003 		(void)chgsbsize(so->so_cred->cr_uidinfo, &so->so_snd.sb_hiwat,
1004 		    newhiwat, RLIM_INFINITY);
1005 		so->so_snd.sb_mbmax -= mbcnt_delta;
1006 		SOCKBUF_UNLOCK(&so->so_snd);
1007 		unp2->unp_cc = sbcc;
1008 		UNP_PCB_UNLOCK(unp2);
1009 		m = NULL;
1010 		break;
1011 
1012 	default:
1013 		panic("uipc_send unknown socktype");
1014 	}
1015 
1016 	/*
1017 	 * PRUS_EOF is equivalent to pru_send followed by pru_shutdown.
1018 	 */
1019 	if (flags & PRUS_EOF) {
1020 		UNP_PCB_LOCK(unp);
1021 		socantsendmore(so);
1022 		unp_shutdown(unp);
1023 		UNP_PCB_UNLOCK(unp);
1024 	}
1025 
1026 	if ((nam != NULL) || (flags & PRUS_EOF))
1027 		UNP_LINK_WUNLOCK();
1028 	else
1029 		UNP_LINK_RUNLOCK();
1030 
1031 	if (control != NULL && error != 0)
1032 		unp_dispose(control);
1033 
1034 release:
1035 	if (control != NULL)
1036 		m_freem(control);
1037 	if (m != NULL)
1038 		m_freem(m);
1039 	return (error);
1040 }
1041 
1042 static int
1043 uipc_sense(struct socket *so, struct stat *sb)
1044 {
1045 	struct unpcb *unp, *unp2;
1046 	struct socket *so2;
1047 
1048 	unp = sotounpcb(so);
1049 	KASSERT(unp != NULL, ("uipc_sense: unp == NULL"));
1050 
1051 	sb->st_blksize = so->so_snd.sb_hiwat;
1052 	UNP_LINK_RLOCK();
1053 	UNP_PCB_LOCK(unp);
1054 	unp2 = unp->unp_conn;
1055 	if ((so->so_type == SOCK_STREAM || so->so_type == SOCK_SEQPACKET) &&
1056 	    unp2 != NULL) {
1057 		so2 = unp2->unp_socket;
1058 		sb->st_blksize += so2->so_rcv.sb_cc;
1059 	}
1060 	sb->st_dev = NODEV;
1061 	if (unp->unp_ino == 0)
1062 		unp->unp_ino = (++unp_ino == 0) ? ++unp_ino : unp_ino;
1063 	sb->st_ino = unp->unp_ino;
1064 	UNP_PCB_UNLOCK(unp);
1065 	UNP_LINK_RUNLOCK();
1066 	return (0);
1067 }
1068 
1069 static int
1070 uipc_shutdown(struct socket *so)
1071 {
1072 	struct unpcb *unp;
1073 
1074 	unp = sotounpcb(so);
1075 	KASSERT(unp != NULL, ("uipc_shutdown: unp == NULL"));
1076 
1077 	UNP_LINK_WLOCK();
1078 	UNP_PCB_LOCK(unp);
1079 	socantsendmore(so);
1080 	unp_shutdown(unp);
1081 	UNP_PCB_UNLOCK(unp);
1082 	UNP_LINK_WUNLOCK();
1083 	return (0);
1084 }
1085 
1086 static int
1087 uipc_sockaddr(struct socket *so, struct sockaddr **nam)
1088 {
1089 	struct unpcb *unp;
1090 	const struct sockaddr *sa;
1091 
1092 	unp = sotounpcb(so);
1093 	KASSERT(unp != NULL, ("uipc_sockaddr: unp == NULL"));
1094 
1095 	*nam = malloc(sizeof(struct sockaddr_un), M_SONAME, M_WAITOK);
1096 	UNP_PCB_LOCK(unp);
1097 	if (unp->unp_addr != NULL)
1098 		sa = (struct sockaddr *) unp->unp_addr;
1099 	else
1100 		sa = &sun_noname;
1101 	bcopy(sa, *nam, sa->sa_len);
1102 	UNP_PCB_UNLOCK(unp);
1103 	return (0);
1104 }
1105 
1106 static struct pr_usrreqs uipc_usrreqs_dgram = {
1107 	.pru_abort = 		uipc_abort,
1108 	.pru_accept =		uipc_accept,
1109 	.pru_attach =		uipc_attach,
1110 	.pru_bind =		uipc_bind,
1111 	.pru_bindat =		uipc_bindat,
1112 	.pru_connect =		uipc_connect,
1113 	.pru_connectat =	uipc_connectat,
1114 	.pru_connect2 =		uipc_connect2,
1115 	.pru_detach =		uipc_detach,
1116 	.pru_disconnect =	uipc_disconnect,
1117 	.pru_listen =		uipc_listen,
1118 	.pru_peeraddr =		uipc_peeraddr,
1119 	.pru_rcvd =		uipc_rcvd,
1120 	.pru_send =		uipc_send,
1121 	.pru_sense =		uipc_sense,
1122 	.pru_shutdown =		uipc_shutdown,
1123 	.pru_sockaddr =		uipc_sockaddr,
1124 	.pru_soreceive =	soreceive_dgram,
1125 	.pru_close =		uipc_close,
1126 };
1127 
1128 static struct pr_usrreqs uipc_usrreqs_seqpacket = {
1129 	.pru_abort =		uipc_abort,
1130 	.pru_accept =		uipc_accept,
1131 	.pru_attach =		uipc_attach,
1132 	.pru_bind =		uipc_bind,
1133 	.pru_bindat =		uipc_bindat,
1134 	.pru_connect =		uipc_connect,
1135 	.pru_connectat =	uipc_connectat,
1136 	.pru_connect2 =		uipc_connect2,
1137 	.pru_detach =		uipc_detach,
1138 	.pru_disconnect =	uipc_disconnect,
1139 	.pru_listen =		uipc_listen,
1140 	.pru_peeraddr =		uipc_peeraddr,
1141 	.pru_rcvd =		uipc_rcvd,
1142 	.pru_send =		uipc_send,
1143 	.pru_sense =		uipc_sense,
1144 	.pru_shutdown =		uipc_shutdown,
1145 	.pru_sockaddr =		uipc_sockaddr,
1146 	.pru_soreceive =	soreceive_generic,	/* XXX: or...? */
1147 	.pru_close =		uipc_close,
1148 };
1149 
1150 static struct pr_usrreqs uipc_usrreqs_stream = {
1151 	.pru_abort = 		uipc_abort,
1152 	.pru_accept =		uipc_accept,
1153 	.pru_attach =		uipc_attach,
1154 	.pru_bind =		uipc_bind,
1155 	.pru_bindat =		uipc_bindat,
1156 	.pru_connect =		uipc_connect,
1157 	.pru_connectat =	uipc_connectat,
1158 	.pru_connect2 =		uipc_connect2,
1159 	.pru_detach =		uipc_detach,
1160 	.pru_disconnect =	uipc_disconnect,
1161 	.pru_listen =		uipc_listen,
1162 	.pru_peeraddr =		uipc_peeraddr,
1163 	.pru_rcvd =		uipc_rcvd,
1164 	.pru_send =		uipc_send,
1165 	.pru_sense =		uipc_sense,
1166 	.pru_shutdown =		uipc_shutdown,
1167 	.pru_sockaddr =		uipc_sockaddr,
1168 	.pru_soreceive =	soreceive_generic,
1169 	.pru_close =		uipc_close,
1170 };
1171 
1172 static int
1173 uipc_ctloutput(struct socket *so, struct sockopt *sopt)
1174 {
1175 	struct unpcb *unp;
1176 	struct xucred xu;
1177 	int error, optval;
1178 
1179 	if (sopt->sopt_level != 0)
1180 		return (EINVAL);
1181 
1182 	unp = sotounpcb(so);
1183 	KASSERT(unp != NULL, ("uipc_ctloutput: unp == NULL"));
1184 	error = 0;
1185 	switch (sopt->sopt_dir) {
1186 	case SOPT_GET:
1187 		switch (sopt->sopt_name) {
1188 		case LOCAL_PEERCRED:
1189 			UNP_PCB_LOCK(unp);
1190 			if (unp->unp_flags & UNP_HAVEPC)
1191 				xu = unp->unp_peercred;
1192 			else {
1193 				if (so->so_type == SOCK_STREAM)
1194 					error = ENOTCONN;
1195 				else
1196 					error = EINVAL;
1197 			}
1198 			UNP_PCB_UNLOCK(unp);
1199 			if (error == 0)
1200 				error = sooptcopyout(sopt, &xu, sizeof(xu));
1201 			break;
1202 
1203 		case LOCAL_CREDS:
1204 			/* Unlocked read. */
1205 			optval = unp->unp_flags & UNP_WANTCRED ? 1 : 0;
1206 			error = sooptcopyout(sopt, &optval, sizeof(optval));
1207 			break;
1208 
1209 		case LOCAL_CONNWAIT:
1210 			/* Unlocked read. */
1211 			optval = unp->unp_flags & UNP_CONNWAIT ? 1 : 0;
1212 			error = sooptcopyout(sopt, &optval, sizeof(optval));
1213 			break;
1214 
1215 		default:
1216 			error = EOPNOTSUPP;
1217 			break;
1218 		}
1219 		break;
1220 
1221 	case SOPT_SET:
1222 		switch (sopt->sopt_name) {
1223 		case LOCAL_CREDS:
1224 		case LOCAL_CONNWAIT:
1225 			error = sooptcopyin(sopt, &optval, sizeof(optval),
1226 					    sizeof(optval));
1227 			if (error)
1228 				break;
1229 
1230 #define	OPTSET(bit) do {						\
1231 	UNP_PCB_LOCK(unp);						\
1232 	if (optval)							\
1233 		unp->unp_flags |= bit;					\
1234 	else								\
1235 		unp->unp_flags &= ~bit;					\
1236 	UNP_PCB_UNLOCK(unp);						\
1237 } while (0)
1238 
1239 			switch (sopt->sopt_name) {
1240 			case LOCAL_CREDS:
1241 				OPTSET(UNP_WANTCRED);
1242 				break;
1243 
1244 			case LOCAL_CONNWAIT:
1245 				OPTSET(UNP_CONNWAIT);
1246 				break;
1247 
1248 			default:
1249 				break;
1250 			}
1251 			break;
1252 #undef	OPTSET
1253 		default:
1254 			error = ENOPROTOOPT;
1255 			break;
1256 		}
1257 		break;
1258 
1259 	default:
1260 		error = EOPNOTSUPP;
1261 		break;
1262 	}
1263 	return (error);
1264 }
1265 
1266 static int
1267 unp_connect(struct socket *so, struct sockaddr *nam, struct thread *td)
1268 {
1269 
1270 	return (unp_connectat(AT_FDCWD, so, nam, td));
1271 }
1272 
1273 static int
1274 unp_connectat(int fd, struct socket *so, struct sockaddr *nam,
1275     struct thread *td)
1276 {
1277 	struct sockaddr_un *soun = (struct sockaddr_un *)nam;
1278 	struct vnode *vp;
1279 	struct socket *so2, *so3;
1280 	struct unpcb *unp, *unp2, *unp3;
1281 	struct nameidata nd;
1282 	char buf[SOCK_MAXADDRLEN];
1283 	struct sockaddr *sa;
1284 	cap_rights_t rights;
1285 	int error, len;
1286 
1287 	UNP_LINK_WLOCK_ASSERT();
1288 
1289 	unp = sotounpcb(so);
1290 	KASSERT(unp != NULL, ("unp_connect: unp == NULL"));
1291 
1292 	if (nam->sa_len > sizeof(struct sockaddr_un))
1293 		return (EINVAL);
1294 	len = nam->sa_len - offsetof(struct sockaddr_un, sun_path);
1295 	if (len <= 0)
1296 		return (EINVAL);
1297 	bcopy(soun->sun_path, buf, len);
1298 	buf[len] = 0;
1299 
1300 	UNP_PCB_LOCK(unp);
1301 	if (unp->unp_flags & UNP_CONNECTING) {
1302 		UNP_PCB_UNLOCK(unp);
1303 		return (EALREADY);
1304 	}
1305 	UNP_LINK_WUNLOCK();
1306 	unp->unp_flags |= UNP_CONNECTING;
1307 	UNP_PCB_UNLOCK(unp);
1308 
1309 	sa = malloc(sizeof(struct sockaddr_un), M_SONAME, M_WAITOK);
1310 	NDINIT_ATRIGHTS(&nd, LOOKUP, FOLLOW | LOCKSHARED | LOCKLEAF,
1311 	    UIO_SYSSPACE, buf, fd, cap_rights_init(&rights, CAP_CONNECTAT), td);
1312 	error = namei(&nd);
1313 	if (error)
1314 		vp = NULL;
1315 	else
1316 		vp = nd.ni_vp;
1317 	ASSERT_VOP_LOCKED(vp, "unp_connect");
1318 	NDFREE(&nd, NDF_ONLY_PNBUF);
1319 	if (error)
1320 		goto bad;
1321 
1322 	if (vp->v_type != VSOCK) {
1323 		error = ENOTSOCK;
1324 		goto bad;
1325 	}
1326 #ifdef MAC
1327 	error = mac_vnode_check_open(td->td_ucred, vp, VWRITE | VREAD);
1328 	if (error)
1329 		goto bad;
1330 #endif
1331 	error = VOP_ACCESS(vp, VWRITE, td->td_ucred, td);
1332 	if (error)
1333 		goto bad;
1334 
1335 	unp = sotounpcb(so);
1336 	KASSERT(unp != NULL, ("unp_connect: unp == NULL"));
1337 
1338 	/*
1339 	 * Lock linkage lock for two reasons: make sure v_socket is stable,
1340 	 * and to protect simultaneous locking of multiple pcbs.
1341 	 */
1342 	UNP_LINK_WLOCK();
1343 	VOP_UNP_CONNECT(vp, &so2);
1344 	if (so2 == NULL) {
1345 		error = ECONNREFUSED;
1346 		goto bad2;
1347 	}
1348 	if (so->so_type != so2->so_type) {
1349 		error = EPROTOTYPE;
1350 		goto bad2;
1351 	}
1352 	if (so->so_proto->pr_flags & PR_CONNREQUIRED) {
1353 		if (so2->so_options & SO_ACCEPTCONN) {
1354 			CURVNET_SET(so2->so_vnet);
1355 			so3 = sonewconn(so2, 0);
1356 			CURVNET_RESTORE();
1357 		} else
1358 			so3 = NULL;
1359 		if (so3 == NULL) {
1360 			error = ECONNREFUSED;
1361 			goto bad2;
1362 		}
1363 		unp = sotounpcb(so);
1364 		unp2 = sotounpcb(so2);
1365 		unp3 = sotounpcb(so3);
1366 		UNP_PCB_LOCK(unp);
1367 		UNP_PCB_LOCK(unp2);
1368 		UNP_PCB_LOCK(unp3);
1369 		if (unp2->unp_addr != NULL) {
1370 			bcopy(unp2->unp_addr, sa, unp2->unp_addr->sun_len);
1371 			unp3->unp_addr = (struct sockaddr_un *) sa;
1372 			sa = NULL;
1373 		}
1374 
1375 		/*
1376 		 * The connector's (client's) credentials are copied from its
1377 		 * process structure at the time of connect() (which is now).
1378 		 */
1379 		cru2x(td->td_ucred, &unp3->unp_peercred);
1380 		unp3->unp_flags |= UNP_HAVEPC;
1381 
1382 		/*
1383 		 * The receiver's (server's) credentials are copied from the
1384 		 * unp_peercred member of socket on which the former called
1385 		 * listen(); uipc_listen() cached that process's credentials
1386 		 * at that time so we can use them now.
1387 		 */
1388 		KASSERT(unp2->unp_flags & UNP_HAVEPCCACHED,
1389 		    ("unp_connect: listener without cached peercred"));
1390 		memcpy(&unp->unp_peercred, &unp2->unp_peercred,
1391 		    sizeof(unp->unp_peercred));
1392 		unp->unp_flags |= UNP_HAVEPC;
1393 		if (unp2->unp_flags & UNP_WANTCRED)
1394 			unp3->unp_flags |= UNP_WANTCRED;
1395 		UNP_PCB_UNLOCK(unp3);
1396 		UNP_PCB_UNLOCK(unp2);
1397 		UNP_PCB_UNLOCK(unp);
1398 #ifdef MAC
1399 		mac_socketpeer_set_from_socket(so, so3);
1400 		mac_socketpeer_set_from_socket(so3, so);
1401 #endif
1402 
1403 		so2 = so3;
1404 	}
1405 	unp = sotounpcb(so);
1406 	KASSERT(unp != NULL, ("unp_connect: unp == NULL"));
1407 	unp2 = sotounpcb(so2);
1408 	KASSERT(unp2 != NULL, ("unp_connect: unp2 == NULL"));
1409 	UNP_PCB_LOCK(unp);
1410 	UNP_PCB_LOCK(unp2);
1411 	error = unp_connect2(so, so2, PRU_CONNECT);
1412 	UNP_PCB_UNLOCK(unp2);
1413 	UNP_PCB_UNLOCK(unp);
1414 bad2:
1415 	UNP_LINK_WUNLOCK();
1416 bad:
1417 	if (vp != NULL)
1418 		vput(vp);
1419 	free(sa, M_SONAME);
1420 	UNP_LINK_WLOCK();
1421 	UNP_PCB_LOCK(unp);
1422 	unp->unp_flags &= ~UNP_CONNECTING;
1423 	UNP_PCB_UNLOCK(unp);
1424 	return (error);
1425 }
1426 
1427 static int
1428 unp_connect2(struct socket *so, struct socket *so2, int req)
1429 {
1430 	struct unpcb *unp;
1431 	struct unpcb *unp2;
1432 
1433 	unp = sotounpcb(so);
1434 	KASSERT(unp != NULL, ("unp_connect2: unp == NULL"));
1435 	unp2 = sotounpcb(so2);
1436 	KASSERT(unp2 != NULL, ("unp_connect2: unp2 == NULL"));
1437 
1438 	UNP_LINK_WLOCK_ASSERT();
1439 	UNP_PCB_LOCK_ASSERT(unp);
1440 	UNP_PCB_LOCK_ASSERT(unp2);
1441 
1442 	if (so2->so_type != so->so_type)
1443 		return (EPROTOTYPE);
1444 	unp->unp_conn = unp2;
1445 
1446 	switch (so->so_type) {
1447 	case SOCK_DGRAM:
1448 		LIST_INSERT_HEAD(&unp2->unp_refs, unp, unp_reflink);
1449 		soisconnected(so);
1450 		break;
1451 
1452 	case SOCK_STREAM:
1453 	case SOCK_SEQPACKET:
1454 		unp2->unp_conn = unp;
1455 		if (req == PRU_CONNECT &&
1456 		    ((unp->unp_flags | unp2->unp_flags) & UNP_CONNWAIT))
1457 			soisconnecting(so);
1458 		else
1459 			soisconnected(so);
1460 		soisconnected(so2);
1461 		break;
1462 
1463 	default:
1464 		panic("unp_connect2");
1465 	}
1466 	return (0);
1467 }
1468 
1469 static void
1470 unp_disconnect(struct unpcb *unp, struct unpcb *unp2)
1471 {
1472 	struct socket *so;
1473 
1474 	KASSERT(unp2 != NULL, ("unp_disconnect: unp2 == NULL"));
1475 
1476 	UNP_LINK_WLOCK_ASSERT();
1477 	UNP_PCB_LOCK_ASSERT(unp);
1478 	UNP_PCB_LOCK_ASSERT(unp2);
1479 
1480 	unp->unp_conn = NULL;
1481 	switch (unp->unp_socket->so_type) {
1482 	case SOCK_DGRAM:
1483 		LIST_REMOVE(unp, unp_reflink);
1484 		so = unp->unp_socket;
1485 		SOCK_LOCK(so);
1486 		so->so_state &= ~SS_ISCONNECTED;
1487 		SOCK_UNLOCK(so);
1488 		break;
1489 
1490 	case SOCK_STREAM:
1491 	case SOCK_SEQPACKET:
1492 		soisdisconnected(unp->unp_socket);
1493 		unp2->unp_conn = NULL;
1494 		soisdisconnected(unp2->unp_socket);
1495 		break;
1496 	}
1497 }
1498 
1499 /*
1500  * unp_pcblist() walks the global list of struct unpcb's to generate a
1501  * pointer list, bumping the refcount on each unpcb.  It then copies them out
1502  * sequentially, validating the generation number on each to see if it has
1503  * been detached.  All of this is necessary because copyout() may sleep on
1504  * disk I/O.
1505  */
1506 static int
1507 unp_pcblist(SYSCTL_HANDLER_ARGS)
1508 {
1509 	int error, i, n;
1510 	int freeunp;
1511 	struct unpcb *unp, **unp_list;
1512 	unp_gen_t gencnt;
1513 	struct xunpgen *xug;
1514 	struct unp_head *head;
1515 	struct xunpcb *xu;
1516 
1517 	switch ((intptr_t)arg1) {
1518 	case SOCK_STREAM:
1519 		head = &unp_shead;
1520 		break;
1521 
1522 	case SOCK_DGRAM:
1523 		head = &unp_dhead;
1524 		break;
1525 
1526 	case SOCK_SEQPACKET:
1527 		head = &unp_sphead;
1528 		break;
1529 
1530 	default:
1531 		panic("unp_pcblist: arg1 %d", (int)(intptr_t)arg1);
1532 	}
1533 
1534 	/*
1535 	 * The process of preparing the PCB list is too time-consuming and
1536 	 * resource-intensive to repeat twice on every request.
1537 	 */
1538 	if (req->oldptr == NULL) {
1539 		n = unp_count;
1540 		req->oldidx = 2 * (sizeof *xug)
1541 			+ (n + n/8) * sizeof(struct xunpcb);
1542 		return (0);
1543 	}
1544 
1545 	if (req->newptr != NULL)
1546 		return (EPERM);
1547 
1548 	/*
1549 	 * OK, now we're committed to doing something.
1550 	 */
1551 	xug = malloc(sizeof(*xug), M_TEMP, M_WAITOK);
1552 	UNP_LIST_LOCK();
1553 	gencnt = unp_gencnt;
1554 	n = unp_count;
1555 	UNP_LIST_UNLOCK();
1556 
1557 	xug->xug_len = sizeof *xug;
1558 	xug->xug_count = n;
1559 	xug->xug_gen = gencnt;
1560 	xug->xug_sogen = so_gencnt;
1561 	error = SYSCTL_OUT(req, xug, sizeof *xug);
1562 	if (error) {
1563 		free(xug, M_TEMP);
1564 		return (error);
1565 	}
1566 
1567 	unp_list = malloc(n * sizeof *unp_list, M_TEMP, M_WAITOK);
1568 
1569 	UNP_LIST_LOCK();
1570 	for (unp = LIST_FIRST(head), i = 0; unp && i < n;
1571 	     unp = LIST_NEXT(unp, unp_link)) {
1572 		UNP_PCB_LOCK(unp);
1573 		if (unp->unp_gencnt <= gencnt) {
1574 			if (cr_cansee(req->td->td_ucred,
1575 			    unp->unp_socket->so_cred)) {
1576 				UNP_PCB_UNLOCK(unp);
1577 				continue;
1578 			}
1579 			unp_list[i++] = unp;
1580 			unp->unp_refcount++;
1581 		}
1582 		UNP_PCB_UNLOCK(unp);
1583 	}
1584 	UNP_LIST_UNLOCK();
1585 	n = i;			/* In case we lost some during malloc. */
1586 
1587 	error = 0;
1588 	xu = malloc(sizeof(*xu), M_TEMP, M_WAITOK | M_ZERO);
1589 	for (i = 0; i < n; i++) {
1590 		unp = unp_list[i];
1591 		UNP_PCB_LOCK(unp);
1592 		unp->unp_refcount--;
1593 	        if (unp->unp_refcount != 0 && unp->unp_gencnt <= gencnt) {
1594 			xu->xu_len = sizeof *xu;
1595 			xu->xu_unpp = unp;
1596 			/*
1597 			 * XXX - need more locking here to protect against
1598 			 * connect/disconnect races for SMP.
1599 			 */
1600 			if (unp->unp_addr != NULL)
1601 				bcopy(unp->unp_addr, &xu->xu_addr,
1602 				      unp->unp_addr->sun_len);
1603 			if (unp->unp_conn != NULL &&
1604 			    unp->unp_conn->unp_addr != NULL)
1605 				bcopy(unp->unp_conn->unp_addr,
1606 				      &xu->xu_caddr,
1607 				      unp->unp_conn->unp_addr->sun_len);
1608 			bcopy(unp, &xu->xu_unp, sizeof *unp);
1609 			sotoxsocket(unp->unp_socket, &xu->xu_socket);
1610 			UNP_PCB_UNLOCK(unp);
1611 			error = SYSCTL_OUT(req, xu, sizeof *xu);
1612 		} else {
1613 			freeunp = (unp->unp_refcount == 0);
1614 			UNP_PCB_UNLOCK(unp);
1615 			if (freeunp) {
1616 				UNP_PCB_LOCK_DESTROY(unp);
1617 				uma_zfree(unp_zone, unp);
1618 			}
1619 		}
1620 	}
1621 	free(xu, M_TEMP);
1622 	if (!error) {
1623 		/*
1624 		 * Give the user an updated idea of our state.  If the
1625 		 * generation differs from what we told her before, she knows
1626 		 * that something happened while we were processing this
1627 		 * request, and it might be necessary to retry.
1628 		 */
1629 		xug->xug_gen = unp_gencnt;
1630 		xug->xug_sogen = so_gencnt;
1631 		xug->xug_count = unp_count;
1632 		error = SYSCTL_OUT(req, xug, sizeof *xug);
1633 	}
1634 	free(unp_list, M_TEMP);
1635 	free(xug, M_TEMP);
1636 	return (error);
1637 }
1638 
1639 SYSCTL_PROC(_net_local_dgram, OID_AUTO, pcblist, CTLTYPE_OPAQUE | CTLFLAG_RD,
1640     (void *)(intptr_t)SOCK_DGRAM, 0, unp_pcblist, "S,xunpcb",
1641     "List of active local datagram sockets");
1642 SYSCTL_PROC(_net_local_stream, OID_AUTO, pcblist, CTLTYPE_OPAQUE | CTLFLAG_RD,
1643     (void *)(intptr_t)SOCK_STREAM, 0, unp_pcblist, "S,xunpcb",
1644     "List of active local stream sockets");
1645 SYSCTL_PROC(_net_local_seqpacket, OID_AUTO, pcblist,
1646     CTLTYPE_OPAQUE | CTLFLAG_RD,
1647     (void *)(intptr_t)SOCK_SEQPACKET, 0, unp_pcblist, "S,xunpcb",
1648     "List of active local seqpacket sockets");
1649 
1650 static void
1651 unp_shutdown(struct unpcb *unp)
1652 {
1653 	struct unpcb *unp2;
1654 	struct socket *so;
1655 
1656 	UNP_LINK_WLOCK_ASSERT();
1657 	UNP_PCB_LOCK_ASSERT(unp);
1658 
1659 	unp2 = unp->unp_conn;
1660 	if ((unp->unp_socket->so_type == SOCK_STREAM ||
1661 	    (unp->unp_socket->so_type == SOCK_SEQPACKET)) && unp2 != NULL) {
1662 		so = unp2->unp_socket;
1663 		if (so != NULL)
1664 			socantrcvmore(so);
1665 	}
1666 }
1667 
1668 static void
1669 unp_drop(struct unpcb *unp, int errno)
1670 {
1671 	struct socket *so = unp->unp_socket;
1672 	struct unpcb *unp2;
1673 
1674 	UNP_LINK_WLOCK_ASSERT();
1675 	UNP_PCB_LOCK_ASSERT(unp);
1676 
1677 	so->so_error = errno;
1678 	unp2 = unp->unp_conn;
1679 	if (unp2 == NULL)
1680 		return;
1681 	UNP_PCB_LOCK(unp2);
1682 	unp_disconnect(unp, unp2);
1683 	UNP_PCB_UNLOCK(unp2);
1684 }
1685 
1686 static void
1687 unp_freerights(struct filedescent **fdep, int fdcount)
1688 {
1689 	struct file *fp;
1690 	int i;
1691 
1692 	KASSERT(fdcount > 0, ("%s: fdcount %d", __func__, fdcount));
1693 
1694 	for (i = 0; i < fdcount; i++) {
1695 		fp = fdep[i]->fde_file;
1696 		filecaps_free(&fdep[i]->fde_caps);
1697 		unp_discard(fp);
1698 	}
1699 	free(fdep[0], M_FILECAPS);
1700 }
1701 
1702 static int
1703 unp_externalize(struct mbuf *control, struct mbuf **controlp, int flags)
1704 {
1705 	struct thread *td = curthread;		/* XXX */
1706 	struct cmsghdr *cm = mtod(control, struct cmsghdr *);
1707 	int i;
1708 	int *fdp;
1709 	struct filedesc *fdesc = td->td_proc->p_fd;
1710 	struct filedescent *fde, **fdep;
1711 	void *data;
1712 	socklen_t clen = control->m_len, datalen;
1713 	int error, newfds;
1714 	u_int newlen;
1715 
1716 	UNP_LINK_UNLOCK_ASSERT();
1717 
1718 	error = 0;
1719 	if (controlp != NULL) /* controlp == NULL => free control messages */
1720 		*controlp = NULL;
1721 	while (cm != NULL) {
1722 		if (sizeof(*cm) > clen || cm->cmsg_len > clen) {
1723 			error = EINVAL;
1724 			break;
1725 		}
1726 		data = CMSG_DATA(cm);
1727 		datalen = (caddr_t)cm + cm->cmsg_len - (caddr_t)data;
1728 		if (cm->cmsg_level == SOL_SOCKET
1729 		    && cm->cmsg_type == SCM_RIGHTS) {
1730 			newfds = datalen / sizeof(*fdep);
1731 			if (newfds == 0)
1732 				goto next;
1733 			fdep = data;
1734 
1735 			/* If we're not outputting the descriptors free them. */
1736 			if (error || controlp == NULL) {
1737 				unp_freerights(fdep, newfds);
1738 				goto next;
1739 			}
1740 			FILEDESC_XLOCK(fdesc);
1741 
1742 			/*
1743 			 * Now change each pointer to an fd in the global
1744 			 * table to an integer that is the index to the local
1745 			 * fd table entry that we set up to point to the
1746 			 * global one we are transferring.
1747 			 */
1748 			newlen = newfds * sizeof(int);
1749 			*controlp = sbcreatecontrol(NULL, newlen,
1750 			    SCM_RIGHTS, SOL_SOCKET);
1751 			if (*controlp == NULL) {
1752 				FILEDESC_XUNLOCK(fdesc);
1753 				error = E2BIG;
1754 				unp_freerights(fdep, newfds);
1755 				goto next;
1756 			}
1757 
1758 			fdp = (int *)
1759 			    CMSG_DATA(mtod(*controlp, struct cmsghdr *));
1760 			if (fdallocn(td, 0, fdp, newfds) != 0) {
1761 				FILEDESC_XUNLOCK(td->td_proc->p_fd);
1762 				error = EMSGSIZE;
1763 				unp_freerights(fdep, newfds);
1764 				m_freem(*controlp);
1765 				*controlp = NULL;
1766 				goto next;
1767 			}
1768 			for (i = 0; i < newfds; i++, fdp++) {
1769 				fde = &fdesc->fd_ofiles[*fdp];
1770 				fde->fde_file = fdep[i]->fde_file;
1771 				filecaps_move(&fdep[i]->fde_caps,
1772 				    &fde->fde_caps);
1773 				if ((flags & MSG_CMSG_CLOEXEC) != 0)
1774 					fde->fde_flags |= UF_EXCLOSE;
1775 				unp_externalize_fp(fde->fde_file);
1776 			}
1777 			FILEDESC_XUNLOCK(fdesc);
1778 			free(fdep[0], M_FILECAPS);
1779 		} else {
1780 			/* We can just copy anything else across. */
1781 			if (error || controlp == NULL)
1782 				goto next;
1783 			*controlp = sbcreatecontrol(NULL, datalen,
1784 			    cm->cmsg_type, cm->cmsg_level);
1785 			if (*controlp == NULL) {
1786 				error = ENOBUFS;
1787 				goto next;
1788 			}
1789 			bcopy(data,
1790 			    CMSG_DATA(mtod(*controlp, struct cmsghdr *)),
1791 			    datalen);
1792 		}
1793 		controlp = &(*controlp)->m_next;
1794 
1795 next:
1796 		if (CMSG_SPACE(datalen) < clen) {
1797 			clen -= CMSG_SPACE(datalen);
1798 			cm = (struct cmsghdr *)
1799 			    ((caddr_t)cm + CMSG_SPACE(datalen));
1800 		} else {
1801 			clen = 0;
1802 			cm = NULL;
1803 		}
1804 	}
1805 
1806 	m_freem(control);
1807 	return (error);
1808 }
1809 
1810 static void
1811 unp_zone_change(void *tag)
1812 {
1813 
1814 	uma_zone_set_max(unp_zone, maxsockets);
1815 }
1816 
1817 static void
1818 unp_init(void)
1819 {
1820 
1821 #ifdef VIMAGE
1822 	if (!IS_DEFAULT_VNET(curvnet))
1823 		return;
1824 #endif
1825 	unp_zone = uma_zcreate("unpcb", sizeof(struct unpcb), NULL, NULL,
1826 	    NULL, NULL, UMA_ALIGN_PTR, 0);
1827 	if (unp_zone == NULL)
1828 		panic("unp_init");
1829 	uma_zone_set_max(unp_zone, maxsockets);
1830 	uma_zone_set_warning(unp_zone, "kern.ipc.maxsockets limit reached");
1831 	EVENTHANDLER_REGISTER(maxsockets_change, unp_zone_change,
1832 	    NULL, EVENTHANDLER_PRI_ANY);
1833 	LIST_INIT(&unp_dhead);
1834 	LIST_INIT(&unp_shead);
1835 	LIST_INIT(&unp_sphead);
1836 	SLIST_INIT(&unp_defers);
1837 	TIMEOUT_TASK_INIT(taskqueue_thread, &unp_gc_task, 0, unp_gc, NULL);
1838 	TASK_INIT(&unp_defer_task, 0, unp_process_defers, NULL);
1839 	UNP_LINK_LOCK_INIT();
1840 	UNP_LIST_LOCK_INIT();
1841 	UNP_DEFERRED_LOCK_INIT();
1842 }
1843 
1844 static int
1845 unp_internalize(struct mbuf **controlp, struct thread *td)
1846 {
1847 	struct mbuf *control = *controlp;
1848 	struct proc *p = td->td_proc;
1849 	struct filedesc *fdesc = p->p_fd;
1850 	struct bintime *bt;
1851 	struct cmsghdr *cm = mtod(control, struct cmsghdr *);
1852 	struct cmsgcred *cmcred;
1853 	struct filedescent *fde, **fdep, *fdev;
1854 	struct file *fp;
1855 	struct timeval *tv;
1856 	int i, fd, *fdp;
1857 	void *data;
1858 	socklen_t clen = control->m_len, datalen;
1859 	int error, oldfds;
1860 	u_int newlen;
1861 
1862 	UNP_LINK_UNLOCK_ASSERT();
1863 
1864 	error = 0;
1865 	*controlp = NULL;
1866 	while (cm != NULL) {
1867 		if (sizeof(*cm) > clen || cm->cmsg_level != SOL_SOCKET
1868 		    || cm->cmsg_len > clen) {
1869 			error = EINVAL;
1870 			goto out;
1871 		}
1872 		data = CMSG_DATA(cm);
1873 		datalen = (caddr_t)cm + cm->cmsg_len - (caddr_t)data;
1874 
1875 		switch (cm->cmsg_type) {
1876 		/*
1877 		 * Fill in credential information.
1878 		 */
1879 		case SCM_CREDS:
1880 			*controlp = sbcreatecontrol(NULL, sizeof(*cmcred),
1881 			    SCM_CREDS, SOL_SOCKET);
1882 			if (*controlp == NULL) {
1883 				error = ENOBUFS;
1884 				goto out;
1885 			}
1886 			cmcred = (struct cmsgcred *)
1887 			    CMSG_DATA(mtod(*controlp, struct cmsghdr *));
1888 			cmcred->cmcred_pid = p->p_pid;
1889 			cmcred->cmcred_uid = td->td_ucred->cr_ruid;
1890 			cmcred->cmcred_gid = td->td_ucred->cr_rgid;
1891 			cmcred->cmcred_euid = td->td_ucred->cr_uid;
1892 			cmcred->cmcred_ngroups = MIN(td->td_ucred->cr_ngroups,
1893 			    CMGROUP_MAX);
1894 			for (i = 0; i < cmcred->cmcred_ngroups; i++)
1895 				cmcred->cmcred_groups[i] =
1896 				    td->td_ucred->cr_groups[i];
1897 			break;
1898 
1899 		case SCM_RIGHTS:
1900 			oldfds = datalen / sizeof (int);
1901 			if (oldfds == 0)
1902 				break;
1903 			/*
1904 			 * Check that all the FDs passed in refer to legal
1905 			 * files.  If not, reject the entire operation.
1906 			 */
1907 			fdp = data;
1908 			FILEDESC_SLOCK(fdesc);
1909 			for (i = 0; i < oldfds; i++) {
1910 				fd = *fdp++;
1911 				if (fget_locked(fdesc, fd) == NULL) {
1912 					FILEDESC_SUNLOCK(fdesc);
1913 					error = EBADF;
1914 					goto out;
1915 				}
1916 				fp = fdesc->fd_ofiles[fd].fde_file;
1917 				if (!(fp->f_ops->fo_flags & DFLAG_PASSABLE)) {
1918 					FILEDESC_SUNLOCK(fdesc);
1919 					error = EOPNOTSUPP;
1920 					goto out;
1921 				}
1922 
1923 			}
1924 
1925 			/*
1926 			 * Now replace the integer FDs with pointers to the
1927 			 * file structure and capability rights.
1928 			 */
1929 			newlen = oldfds * sizeof(fdep[0]);
1930 			*controlp = sbcreatecontrol(NULL, newlen,
1931 			    SCM_RIGHTS, SOL_SOCKET);
1932 			if (*controlp == NULL) {
1933 				FILEDESC_SUNLOCK(fdesc);
1934 				error = E2BIG;
1935 				goto out;
1936 			}
1937 			fdp = data;
1938 			fdep = (struct filedescent **)
1939 			    CMSG_DATA(mtod(*controlp, struct cmsghdr *));
1940 			fdev = malloc(sizeof(*fdev) * oldfds, M_FILECAPS,
1941 			    M_WAITOK);
1942 			for (i = 0; i < oldfds; i++, fdev++, fdp++) {
1943 				fde = &fdesc->fd_ofiles[*fdp];
1944 				fdep[i] = fdev;
1945 				fdep[i]->fde_file = fde->fde_file;
1946 				filecaps_copy(&fde->fde_caps,
1947 				    &fdep[i]->fde_caps);
1948 				unp_internalize_fp(fdep[i]->fde_file);
1949 			}
1950 			FILEDESC_SUNLOCK(fdesc);
1951 			break;
1952 
1953 		case SCM_TIMESTAMP:
1954 			*controlp = sbcreatecontrol(NULL, sizeof(*tv),
1955 			    SCM_TIMESTAMP, SOL_SOCKET);
1956 			if (*controlp == NULL) {
1957 				error = ENOBUFS;
1958 				goto out;
1959 			}
1960 			tv = (struct timeval *)
1961 			    CMSG_DATA(mtod(*controlp, struct cmsghdr *));
1962 			microtime(tv);
1963 			break;
1964 
1965 		case SCM_BINTIME:
1966 			*controlp = sbcreatecontrol(NULL, sizeof(*bt),
1967 			    SCM_BINTIME, SOL_SOCKET);
1968 			if (*controlp == NULL) {
1969 				error = ENOBUFS;
1970 				goto out;
1971 			}
1972 			bt = (struct bintime *)
1973 			    CMSG_DATA(mtod(*controlp, struct cmsghdr *));
1974 			bintime(bt);
1975 			break;
1976 
1977 		default:
1978 			error = EINVAL;
1979 			goto out;
1980 		}
1981 
1982 		controlp = &(*controlp)->m_next;
1983 		if (CMSG_SPACE(datalen) < clen) {
1984 			clen -= CMSG_SPACE(datalen);
1985 			cm = (struct cmsghdr *)
1986 			    ((caddr_t)cm + CMSG_SPACE(datalen));
1987 		} else {
1988 			clen = 0;
1989 			cm = NULL;
1990 		}
1991 	}
1992 
1993 out:
1994 	m_freem(control);
1995 	return (error);
1996 }
1997 
1998 static struct mbuf *
1999 unp_addsockcred(struct thread *td, struct mbuf *control)
2000 {
2001 	struct mbuf *m, *n, *n_prev;
2002 	struct sockcred *sc;
2003 	const struct cmsghdr *cm;
2004 	int ngroups;
2005 	int i;
2006 
2007 	ngroups = MIN(td->td_ucred->cr_ngroups, CMGROUP_MAX);
2008 	m = sbcreatecontrol(NULL, SOCKCREDSIZE(ngroups), SCM_CREDS, SOL_SOCKET);
2009 	if (m == NULL)
2010 		return (control);
2011 
2012 	sc = (struct sockcred *) CMSG_DATA(mtod(m, struct cmsghdr *));
2013 	sc->sc_uid = td->td_ucred->cr_ruid;
2014 	sc->sc_euid = td->td_ucred->cr_uid;
2015 	sc->sc_gid = td->td_ucred->cr_rgid;
2016 	sc->sc_egid = td->td_ucred->cr_gid;
2017 	sc->sc_ngroups = ngroups;
2018 	for (i = 0; i < sc->sc_ngroups; i++)
2019 		sc->sc_groups[i] = td->td_ucred->cr_groups[i];
2020 
2021 	/*
2022 	 * Unlink SCM_CREDS control messages (struct cmsgcred), since just
2023 	 * created SCM_CREDS control message (struct sockcred) has another
2024 	 * format.
2025 	 */
2026 	if (control != NULL)
2027 		for (n = control, n_prev = NULL; n != NULL;) {
2028 			cm = mtod(n, struct cmsghdr *);
2029     			if (cm->cmsg_level == SOL_SOCKET &&
2030 			    cm->cmsg_type == SCM_CREDS) {
2031     				if (n_prev == NULL)
2032 					control = n->m_next;
2033 				else
2034 					n_prev->m_next = n->m_next;
2035 				n = m_free(n);
2036 			} else {
2037 				n_prev = n;
2038 				n = n->m_next;
2039 			}
2040 		}
2041 
2042 	/* Prepend it to the head. */
2043 	m->m_next = control;
2044 	return (m);
2045 }
2046 
2047 static struct unpcb *
2048 fptounp(struct file *fp)
2049 {
2050 	struct socket *so;
2051 
2052 	if (fp->f_type != DTYPE_SOCKET)
2053 		return (NULL);
2054 	if ((so = fp->f_data) == NULL)
2055 		return (NULL);
2056 	if (so->so_proto->pr_domain != &localdomain)
2057 		return (NULL);
2058 	return sotounpcb(so);
2059 }
2060 
2061 static void
2062 unp_discard(struct file *fp)
2063 {
2064 	struct unp_defer *dr;
2065 
2066 	if (unp_externalize_fp(fp)) {
2067 		dr = malloc(sizeof(*dr), M_TEMP, M_WAITOK);
2068 		dr->ud_fp = fp;
2069 		UNP_DEFERRED_LOCK();
2070 		SLIST_INSERT_HEAD(&unp_defers, dr, ud_link);
2071 		UNP_DEFERRED_UNLOCK();
2072 		atomic_add_int(&unp_defers_count, 1);
2073 		taskqueue_enqueue(taskqueue_thread, &unp_defer_task);
2074 	} else
2075 		(void) closef(fp, (struct thread *)NULL);
2076 }
2077 
2078 static void
2079 unp_process_defers(void *arg __unused, int pending)
2080 {
2081 	struct unp_defer *dr;
2082 	SLIST_HEAD(, unp_defer) drl;
2083 	int count;
2084 
2085 	SLIST_INIT(&drl);
2086 	for (;;) {
2087 		UNP_DEFERRED_LOCK();
2088 		if (SLIST_FIRST(&unp_defers) == NULL) {
2089 			UNP_DEFERRED_UNLOCK();
2090 			break;
2091 		}
2092 		SLIST_SWAP(&unp_defers, &drl, unp_defer);
2093 		UNP_DEFERRED_UNLOCK();
2094 		count = 0;
2095 		while ((dr = SLIST_FIRST(&drl)) != NULL) {
2096 			SLIST_REMOVE_HEAD(&drl, ud_link);
2097 			closef(dr->ud_fp, NULL);
2098 			free(dr, M_TEMP);
2099 			count++;
2100 		}
2101 		atomic_add_int(&unp_defers_count, -count);
2102 	}
2103 }
2104 
2105 static void
2106 unp_internalize_fp(struct file *fp)
2107 {
2108 	struct unpcb *unp;
2109 
2110 	UNP_LINK_WLOCK();
2111 	if ((unp = fptounp(fp)) != NULL) {
2112 		unp->unp_file = fp;
2113 		unp->unp_msgcount++;
2114 	}
2115 	fhold(fp);
2116 	unp_rights++;
2117 	UNP_LINK_WUNLOCK();
2118 }
2119 
2120 static int
2121 unp_externalize_fp(struct file *fp)
2122 {
2123 	struct unpcb *unp;
2124 	int ret;
2125 
2126 	UNP_LINK_WLOCK();
2127 	if ((unp = fptounp(fp)) != NULL) {
2128 		unp->unp_msgcount--;
2129 		ret = 1;
2130 	} else
2131 		ret = 0;
2132 	unp_rights--;
2133 	UNP_LINK_WUNLOCK();
2134 	return (ret);
2135 }
2136 
2137 /*
2138  * unp_defer indicates whether additional work has been defered for a future
2139  * pass through unp_gc().  It is thread local and does not require explicit
2140  * synchronization.
2141  */
2142 static int	unp_marked;
2143 static int	unp_unreachable;
2144 
2145 static void
2146 unp_accessable(struct filedescent **fdep, int fdcount)
2147 {
2148 	struct unpcb *unp;
2149 	struct file *fp;
2150 	int i;
2151 
2152 	for (i = 0; i < fdcount; i++) {
2153 		fp = fdep[i]->fde_file;
2154 		if ((unp = fptounp(fp)) == NULL)
2155 			continue;
2156 		if (unp->unp_gcflag & UNPGC_REF)
2157 			continue;
2158 		unp->unp_gcflag &= ~UNPGC_DEAD;
2159 		unp->unp_gcflag |= UNPGC_REF;
2160 		unp_marked++;
2161 	}
2162 }
2163 
2164 static void
2165 unp_gc_process(struct unpcb *unp)
2166 {
2167 	struct socket *soa;
2168 	struct socket *so;
2169 	struct file *fp;
2170 
2171 	/* Already processed. */
2172 	if (unp->unp_gcflag & UNPGC_SCANNED)
2173 		return;
2174 	fp = unp->unp_file;
2175 
2176 	/*
2177 	 * Check for a socket potentially in a cycle.  It must be in a
2178 	 * queue as indicated by msgcount, and this must equal the file
2179 	 * reference count.  Note that when msgcount is 0 the file is NULL.
2180 	 */
2181 	if ((unp->unp_gcflag & UNPGC_REF) == 0 && fp &&
2182 	    unp->unp_msgcount != 0 && fp->f_count == unp->unp_msgcount) {
2183 		unp->unp_gcflag |= UNPGC_DEAD;
2184 		unp_unreachable++;
2185 		return;
2186 	}
2187 
2188 	/*
2189 	 * Mark all sockets we reference with RIGHTS.
2190 	 */
2191 	so = unp->unp_socket;
2192 	SOCKBUF_LOCK(&so->so_rcv);
2193 	unp_scan(so->so_rcv.sb_mb, unp_accessable);
2194 	SOCKBUF_UNLOCK(&so->so_rcv);
2195 
2196 	/*
2197 	 * Mark all sockets in our accept queue.
2198 	 */
2199 	ACCEPT_LOCK();
2200 	TAILQ_FOREACH(soa, &so->so_comp, so_list) {
2201 		SOCKBUF_LOCK(&soa->so_rcv);
2202 		unp_scan(soa->so_rcv.sb_mb, unp_accessable);
2203 		SOCKBUF_UNLOCK(&soa->so_rcv);
2204 	}
2205 	ACCEPT_UNLOCK();
2206 	unp->unp_gcflag |= UNPGC_SCANNED;
2207 }
2208 
2209 static int unp_recycled;
2210 SYSCTL_INT(_net_local, OID_AUTO, recycled, CTLFLAG_RD, &unp_recycled, 0,
2211     "Number of unreachable sockets claimed by the garbage collector.");
2212 
2213 static int unp_taskcount;
2214 SYSCTL_INT(_net_local, OID_AUTO, taskcount, CTLFLAG_RD, &unp_taskcount, 0,
2215     "Number of times the garbage collector has run.");
2216 
2217 static void
2218 unp_gc(__unused void *arg, int pending)
2219 {
2220 	struct unp_head *heads[] = { &unp_dhead, &unp_shead, &unp_sphead,
2221 				    NULL };
2222 	struct unp_head **head;
2223 	struct file *f, **unref;
2224 	struct unpcb *unp;
2225 	int i, total;
2226 
2227 	unp_taskcount++;
2228 	UNP_LIST_LOCK();
2229 	/*
2230 	 * First clear all gc flags from previous runs.
2231 	 */
2232 	for (head = heads; *head != NULL; head++)
2233 		LIST_FOREACH(unp, *head, unp_link)
2234 			unp->unp_gcflag = 0;
2235 
2236 	/*
2237 	 * Scan marking all reachable sockets with UNPGC_REF.  Once a socket
2238 	 * is reachable all of the sockets it references are reachable.
2239 	 * Stop the scan once we do a complete loop without discovering
2240 	 * a new reachable socket.
2241 	 */
2242 	do {
2243 		unp_unreachable = 0;
2244 		unp_marked = 0;
2245 		for (head = heads; *head != NULL; head++)
2246 			LIST_FOREACH(unp, *head, unp_link)
2247 				unp_gc_process(unp);
2248 	} while (unp_marked);
2249 	UNP_LIST_UNLOCK();
2250 	if (unp_unreachable == 0)
2251 		return;
2252 
2253 	/*
2254 	 * Allocate space for a local list of dead unpcbs.
2255 	 */
2256 	unref = malloc(unp_unreachable * sizeof(struct file *),
2257 	    M_TEMP, M_WAITOK);
2258 
2259 	/*
2260 	 * Iterate looking for sockets which have been specifically marked
2261 	 * as as unreachable and store them locally.
2262 	 */
2263 	UNP_LINK_RLOCK();
2264 	UNP_LIST_LOCK();
2265 	for (total = 0, head = heads; *head != NULL; head++)
2266 		LIST_FOREACH(unp, *head, unp_link)
2267 			if ((unp->unp_gcflag & UNPGC_DEAD) != 0) {
2268 				f = unp->unp_file;
2269 				if (unp->unp_msgcount == 0 || f == NULL ||
2270 				    f->f_count != unp->unp_msgcount)
2271 					continue;
2272 				unref[total++] = f;
2273 				fhold(f);
2274 				KASSERT(total <= unp_unreachable,
2275 				    ("unp_gc: incorrect unreachable count."));
2276 			}
2277 	UNP_LIST_UNLOCK();
2278 	UNP_LINK_RUNLOCK();
2279 
2280 	/*
2281 	 * Now flush all sockets, free'ing rights.  This will free the
2282 	 * struct files associated with these sockets but leave each socket
2283 	 * with one remaining ref.
2284 	 */
2285 	for (i = 0; i < total; i++) {
2286 		struct socket *so;
2287 
2288 		so = unref[i]->f_data;
2289 		CURVNET_SET(so->so_vnet);
2290 		sorflush(so);
2291 		CURVNET_RESTORE();
2292 	}
2293 
2294 	/*
2295 	 * And finally release the sockets so they can be reclaimed.
2296 	 */
2297 	for (i = 0; i < total; i++)
2298 		fdrop(unref[i], NULL);
2299 	unp_recycled += total;
2300 	free(unref, M_TEMP);
2301 }
2302 
2303 static void
2304 unp_dispose(struct mbuf *m)
2305 {
2306 
2307 	if (m)
2308 		unp_scan(m, unp_freerights);
2309 }
2310 
2311 static void
2312 unp_scan(struct mbuf *m0, void (*op)(struct filedescent **, int))
2313 {
2314 	struct mbuf *m;
2315 	struct cmsghdr *cm;
2316 	void *data;
2317 	socklen_t clen, datalen;
2318 
2319 	while (m0 != NULL) {
2320 		for (m = m0; m; m = m->m_next) {
2321 			if (m->m_type != MT_CONTROL)
2322 				continue;
2323 
2324 			cm = mtod(m, struct cmsghdr *);
2325 			clen = m->m_len;
2326 
2327 			while (cm != NULL) {
2328 				if (sizeof(*cm) > clen || cm->cmsg_len > clen)
2329 					break;
2330 
2331 				data = CMSG_DATA(cm);
2332 				datalen = (caddr_t)cm + cm->cmsg_len
2333 				    - (caddr_t)data;
2334 
2335 				if (cm->cmsg_level == SOL_SOCKET &&
2336 				    cm->cmsg_type == SCM_RIGHTS) {
2337 					(*op)(data, datalen /
2338 					    sizeof(struct filedescent *));
2339 				}
2340 
2341 				if (CMSG_SPACE(datalen) < clen) {
2342 					clen -= CMSG_SPACE(datalen);
2343 					cm = (struct cmsghdr *)
2344 					    ((caddr_t)cm + CMSG_SPACE(datalen));
2345 				} else {
2346 					clen = 0;
2347 					cm = NULL;
2348 				}
2349 			}
2350 		}
2351 		m0 = m0->m_act;
2352 	}
2353 }
2354 
2355 /*
2356  * A helper function called by VFS before socket-type vnode reclamation.
2357  * For an active vnode it clears unp_vnode pointer and decrements unp_vnode
2358  * use count.
2359  */
2360 void
2361 vfs_unp_reclaim(struct vnode *vp)
2362 {
2363 	struct socket *so;
2364 	struct unpcb *unp;
2365 	int active;
2366 
2367 	ASSERT_VOP_ELOCKED(vp, "vfs_unp_reclaim");
2368 	KASSERT(vp->v_type == VSOCK,
2369 	    ("vfs_unp_reclaim: vp->v_type != VSOCK"));
2370 
2371 	active = 0;
2372 	UNP_LINK_WLOCK();
2373 	VOP_UNP_CONNECT(vp, &so);
2374 	if (so == NULL)
2375 		goto done;
2376 	unp = sotounpcb(so);
2377 	if (unp == NULL)
2378 		goto done;
2379 	UNP_PCB_LOCK(unp);
2380 	if (unp->unp_vnode == vp) {
2381 		VOP_UNP_DETACH(vp);
2382 		unp->unp_vnode = NULL;
2383 		active = 1;
2384 	}
2385 	UNP_PCB_UNLOCK(unp);
2386 done:
2387 	UNP_LINK_WUNLOCK();
2388 	if (active)
2389 		vunref(vp);
2390 }
2391 
2392 #ifdef DDB
2393 static void
2394 db_print_indent(int indent)
2395 {
2396 	int i;
2397 
2398 	for (i = 0; i < indent; i++)
2399 		db_printf(" ");
2400 }
2401 
2402 static void
2403 db_print_unpflags(int unp_flags)
2404 {
2405 	int comma;
2406 
2407 	comma = 0;
2408 	if (unp_flags & UNP_HAVEPC) {
2409 		db_printf("%sUNP_HAVEPC", comma ? ", " : "");
2410 		comma = 1;
2411 	}
2412 	if (unp_flags & UNP_HAVEPCCACHED) {
2413 		db_printf("%sUNP_HAVEPCCACHED", comma ? ", " : "");
2414 		comma = 1;
2415 	}
2416 	if (unp_flags & UNP_WANTCRED) {
2417 		db_printf("%sUNP_WANTCRED", comma ? ", " : "");
2418 		comma = 1;
2419 	}
2420 	if (unp_flags & UNP_CONNWAIT) {
2421 		db_printf("%sUNP_CONNWAIT", comma ? ", " : "");
2422 		comma = 1;
2423 	}
2424 	if (unp_flags & UNP_CONNECTING) {
2425 		db_printf("%sUNP_CONNECTING", comma ? ", " : "");
2426 		comma = 1;
2427 	}
2428 	if (unp_flags & UNP_BINDING) {
2429 		db_printf("%sUNP_BINDING", comma ? ", " : "");
2430 		comma = 1;
2431 	}
2432 }
2433 
2434 static void
2435 db_print_xucred(int indent, struct xucred *xu)
2436 {
2437 	int comma, i;
2438 
2439 	db_print_indent(indent);
2440 	db_printf("cr_version: %u   cr_uid: %u   cr_ngroups: %d\n",
2441 	    xu->cr_version, xu->cr_uid, xu->cr_ngroups);
2442 	db_print_indent(indent);
2443 	db_printf("cr_groups: ");
2444 	comma = 0;
2445 	for (i = 0; i < xu->cr_ngroups; i++) {
2446 		db_printf("%s%u", comma ? ", " : "", xu->cr_groups[i]);
2447 		comma = 1;
2448 	}
2449 	db_printf("\n");
2450 }
2451 
2452 static void
2453 db_print_unprefs(int indent, struct unp_head *uh)
2454 {
2455 	struct unpcb *unp;
2456 	int counter;
2457 
2458 	counter = 0;
2459 	LIST_FOREACH(unp, uh, unp_reflink) {
2460 		if (counter % 4 == 0)
2461 			db_print_indent(indent);
2462 		db_printf("%p  ", unp);
2463 		if (counter % 4 == 3)
2464 			db_printf("\n");
2465 		counter++;
2466 	}
2467 	if (counter != 0 && counter % 4 != 0)
2468 		db_printf("\n");
2469 }
2470 
2471 DB_SHOW_COMMAND(unpcb, db_show_unpcb)
2472 {
2473 	struct unpcb *unp;
2474 
2475         if (!have_addr) {
2476                 db_printf("usage: show unpcb <addr>\n");
2477                 return;
2478         }
2479         unp = (struct unpcb *)addr;
2480 
2481 	db_printf("unp_socket: %p   unp_vnode: %p\n", unp->unp_socket,
2482 	    unp->unp_vnode);
2483 
2484 	db_printf("unp_ino: %ju   unp_conn: %p\n", (uintmax_t)unp->unp_ino,
2485 	    unp->unp_conn);
2486 
2487 	db_printf("unp_refs:\n");
2488 	db_print_unprefs(2, &unp->unp_refs);
2489 
2490 	/* XXXRW: Would be nice to print the full address, if any. */
2491 	db_printf("unp_addr: %p\n", unp->unp_addr);
2492 
2493 	db_printf("unp_cc: %d   unp_mbcnt: %d   unp_gencnt: %llu\n",
2494 	    unp->unp_cc, unp->unp_mbcnt,
2495 	    (unsigned long long)unp->unp_gencnt);
2496 
2497 	db_printf("unp_flags: %x (", unp->unp_flags);
2498 	db_print_unpflags(unp->unp_flags);
2499 	db_printf(")\n");
2500 
2501 	db_printf("unp_peercred:\n");
2502 	db_print_xucred(2, &unp->unp_peercred);
2503 
2504 	db_printf("unp_refcount: %u\n", unp->unp_refcount);
2505 }
2506 #endif
2507