sys/kern/uipc_usrreq.c

   1 /*
   2  * Copyright (c) 1982, 1986, 1989, 1991, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. Neither the name of the University nor the names of its contributors
  14  *    may be used to endorse or promote products derived from this software
  15  *    without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  *
  29  *      From: @(#)uipc_usrreq.c 8.3 (Berkeley) 1/4/94
  30  * $FreeBSD: src/sys/kern/uipc_usrreq.c,v 1.54.2.10 2003/03/04 17:28:09 nectar Exp $
  31  */
  32
  33 #include <sys/param.h>
  34 #include <sys/systm.h>
  35 #include <sys/kernel.h>
  36 #include <sys/domain.h>
  37 #include <sys/fcntl.h>
  38 #include <sys/malloc.h>         /* XXX must be before <sys/file.h> */
  39 #include <sys/proc.h>
  40 #include <sys/file.h>
  41 #include <sys/filedesc.h>
  42 #include <sys/mbuf.h>
  43 #include <sys/nlookup.h>
  44 #include <sys/protosw.h>
  45 #include <sys/socket.h>
  46 #include <sys/socketvar.h>
  47 #include <sys/resourcevar.h>
  48 #include <sys/stat.h>
  49 #include <sys/mount.h>
  50 #include <sys/sysctl.h>
  51 #include <sys/un.h>
  52 #include <sys/unpcb.h>
  53 #include <sys/vnode.h>
  54 #include <sys/kern_syscall.h>
  55 #include <sys/taskqueue.h>
  56
  57 #include <sys/file2.h>
  58 #include <sys/spinlock2.h>
  59 #include <sys/socketvar2.h>
  60 #include <sys/msgport2.h>
  61
  62 /*
  63  * Unix communications domain.
  64  *
  65  * TODO:
  66  *      RDM
  67  *      rethink name space problems
  68  *      need a proper out-of-band
  69  *      lock pushdown
  70  *
  71  *
  72  * Unix domain sockets GC.
  73  *
  74  * It was originally designed to address following three cases:
  75  * 1) Receiving unix domain socket can not accept the rights, e.g.
  76  *    when the so_rcv is full.
  77  * 2) Caller of recvmsg(2) does not pass buffer to receive rights.
  78  * 3) Unix domain sockets loop reference, e.g. s1 is on s2.so_rcv,
  79  *    while s2 on s1.so_rcv.
  80  *
  81  * Code under UNP_GC_ALLFILES is intended to address all above three
  82  * cases.  However, 1) was addressed a long time ago in uipc_send()
  83  * (we inheritted the fix from FreeBSD when DragonFly forked).  2)
  84  * was addressed in soreceive() by git-e62cfe62.  3) is the only
  85  * case that needs GC.  The new code (!UNP_GC_ALLFILES) addresses
  86  * case 3) in the following way:
  87  * - Record the struct file in unpcb, if the Unix domain socket is
  88  *   passed as one of the rights.
  89  * - At GC time, only unpcbs are scanned, and only Unix domain sockets
  90  *   that are still used as rights are potential GC targets.
  91  */
  92
  93 #define UNP_DETACHED            UNP_PRIVATE1
  94 #define UNP_CONNECTING          UNP_PRIVATE2
  95 #define UNP_DROPPED             UNP_PRIVATE3
  96 #define UNP_MARKER              UNP_PRIVATE4
  97
  98 #define UNPGC_REF               0x1     /* unpcb has external ref. */
  99 #define UNPGC_DEAD              0x2     /* unpcb might be dead. */
 100 #define UNPGC_SCANNED           0x4     /* Has been scanned. */
 101
 102 #define UNP_GCFILE_MAX          256
 103
 104 /* For unp_internalize() and unp_externalize() */
 105 CTASSERT(sizeof(struct file *) >= sizeof(int));
 106
 107 #define UNP_ISATTACHED(unp)     \
 108     ((unp) != NULL && ((unp)->unp_flags & UNP_DETACHED) == 0)
 109
 110 #ifdef INVARIANTS
 111 #define UNP_ASSERT_TOKEN_HELD(unp) \
 112     ASSERT_LWKT_TOKEN_HELD(lwkt_token_pool_lookup((unp)))
 113 #else   /* !INVARIANTS */
 114 #define UNP_ASSERT_TOKEN_HELD(unp)
 115 #endif  /* INVARIANTS */
 116
 117 struct unp_defdiscard {
 118         SLIST_ENTRY(unp_defdiscard) next;
 119         struct file *fp;
 120 };
 121 SLIST_HEAD(unp_defdiscard_list, unp_defdiscard);
 122
 123 TAILQ_HEAD(unpcb_qhead, unpcb);
 124 struct unp_global_head {
 125         struct unpcb_qhead      list;
 126         int                     count;
 127 };
 128
 129 static  MALLOC_DEFINE(M_UNPCB, "unpcb", "unpcb struct");
 130 static  unp_gen_t unp_gencnt;
 131
 132 static struct unp_global_head unp_stream_head;
 133 static struct unp_global_head unp_dgram_head;
 134 static struct unp_global_head unp_seqpkt_head;
 135
 136 static struct unp_global_head * const unp_heads[] =
 137     { &unp_stream_head, &unp_dgram_head, &unp_seqpkt_head, NULL };
 138
 139 static struct lwkt_token unp_token = LWKT_TOKEN_INITIALIZER(unp_token);
 140 static struct taskqueue *unp_taskqueue;
 141
 142 static struct unp_defdiscard_list unp_defdiscard_head;
 143 static struct spinlock unp_defdiscard_spin;
 144 static struct task unp_defdiscard_task;
 145
 146 static struct   sockaddr sun_noname = { sizeof(sun_noname), AF_LOCAL };
 147 static ino_t    unp_ino = 1;            /* prototype for fake inode numbers */
 148
 149 static int     unp_attach (struct socket *, struct pru_attach_info *);
 150 static void    unp_detach (struct unpcb *);
 151 static int     unp_bind (struct unpcb *,struct sockaddr *, struct thread *);
 152 static int     unp_connect (struct socket *,struct sockaddr *,
 153                                 struct thread *);
 154 static void    unp_disconnect(struct unpcb *, int);
 155 static void    unp_shutdown (struct unpcb *);
 156 static void    unp_gc(void *, int);
 157 #ifdef UNP_GC_ALLFILES
 158 static int     unp_gc_clearmarks(struct file *, void *);
 159 static int     unp_gc_checkmarks(struct file *, void *);
 160 static int     unp_gc_checkrefs(struct file *, void *);
 161 static void    unp_mark(struct file *, void *data);
 162 #endif
 163 static void    unp_scan (struct mbuf *, void (*)(struct file *, void *),
 164                                 void *data);
 165 static void    unp_discard (struct file *, void *);
 166 static int     unp_internalize (struct mbuf *, struct thread *);
 167 static int     unp_listen (struct unpcb *, struct thread *);
 168 static void    unp_fp_externalize(struct lwp *lp, struct file *fp, int fd,
 169                    int flags);
 170 static int     unp_find_lockref(struct sockaddr *nam, struct thread *td,
 171                    short type, struct unpcb **unp_ret);
 172 static int     unp_connect_pair(struct unpcb *unp, struct unpcb *unp2);
 173 static void    unp_drop(struct unpcb *unp, int error);
 174 static void    unp_defdiscard_taskfunc(void *, int);
 175
 176 static int      unp_rights;                     /* file descriptors in flight */
 177 static struct lwkt_token unp_rights_token =
 178     LWKT_TOKEN_INITIALIZER(unp_rights_token);
 179 static struct task unp_gc_task;
 180 static struct unpcb *unp_gc_marker;
 181
 182 SYSCTL_DECL(_net_local);
 183 SYSCTL_INT(_net_local, OID_AUTO, inflight, CTLFLAG_RD, &unp_rights, 0,
 184    "File descriptors in flight");
 185
 186 /*
 187  * SMP Considerations:
 188  *
 189  *      Since unp_token will be automaticly released upon execution of
 190  *      blocking code, we need to reference unp_conn before any possible
 191  *      blocking code to prevent it from being ripped behind our back.
 192  *
 193  *      Any adjustment to unp->unp_conn requires both the global unp_token
 194  *      AND the per-unp token (lwkt_token_pool_lookup(unp)) to be held.
 195  *
 196  *      Any access to so_pcb to obtain unp requires the pool token for
 197  *      unp to be held.
 198  */
 199
 200 static __inline void
 201 unp_reference(struct unpcb *unp)
 202 {
 203         /* 0->1 transition will not work */
 204         KKASSERT(unp->unp_refcnt > 0);
 205         atomic_add_int(&unp->unp_refcnt, 1);
 206 }
 207
 208 static __inline void
 209 unp_free(struct unpcb *unp)
 210 {
 211         KKASSERT(unp->unp_refcnt > 0);
 212         if (atomic_fetchadd_int(&unp->unp_refcnt, -1) == 1)
 213                 unp_detach(unp);
 214 }
 215
 216 static __inline struct unpcb *
 217 unp_getsocktoken(struct socket *so)
 218 {
 219         struct unpcb *unp;
 220
 221         /*
 222          * The unp pointer is invalid until we verify that it is
 223          * good by re-checking so_pcb AFTER obtaining the token.
 224          */
 225         while ((unp = so->so_pcb) != NULL) {
 226                 lwkt_getpooltoken(unp);
 227                 if (unp == so->so_pcb)
 228                         break;
 229                 lwkt_relpooltoken(unp);
 230         }
 231         return unp;
 232 }
 233
 234 static __inline void
 235 unp_reltoken(struct unpcb *unp)
 236 {
 237         if (unp != NULL)
 238                 lwkt_relpooltoken(unp);
 239 }
 240
 241 static __inline void
 242 unp_setflags(struct unpcb *unp, int flags)
 243 {
 244         atomic_set_int(&unp->unp_flags, flags);
 245 }
 246
 247 static __inline void
 248 unp_clrflags(struct unpcb *unp, int flags)
 249 {
 250         atomic_clear_int(&unp->unp_flags, flags);
 251 }
 252
 253 static __inline struct unp_global_head *
 254 unp_globalhead(short type)
 255 {
 256         switch (type) {
 257         case SOCK_STREAM:
 258                 return &unp_stream_head;
 259         case SOCK_DGRAM:
 260                 return &unp_dgram_head;
 261         case SOCK_SEQPACKET:
 262                 return &unp_seqpkt_head;
 263         default:
 264                 panic("unknown socket type %d", type);
 265         }
 266 }
 267
 268 static __inline struct unpcb *
 269 unp_fp2unpcb(struct file *fp)
 270 {
 271         struct socket *so;
 272
 273         if (fp->f_type != DTYPE_SOCKET)
 274                 return NULL;
 275
 276         so = fp->f_data;
 277         if (so == NULL)
 278                 return NULL;
 279
 280         if (so->so_proto->pr_domain != &localdomain)
 281                 return NULL;
 282
 283         return so->so_pcb;
 284 }
 285
 286 static __inline void
 287 unp_add_right(struct file *fp)
 288 {
 289         struct unpcb *unp;
 290
 291         ASSERT_LWKT_TOKEN_HELD(&unp_rights_token);
 292         KASSERT(fp->f_count > 0, ("invalid f_count %d", fp->f_count));
 293
 294         unp = unp_fp2unpcb(fp);
 295         if (unp != NULL) {
 296                 unp->unp_fp = fp;
 297                 unp->unp_msgcount++;
 298         }
 299         fp->f_msgcount++;
 300         unp_rights++;
 301 }
 302
 303 static __inline void
 304 unp_del_right(struct file *fp)
 305 {
 306         struct unpcb *unp;
 307
 308         ASSERT_LWKT_TOKEN_HELD(&unp_rights_token);
 309         KASSERT(fp->f_count > 0, ("invalid f_count %d", fp->f_count));
 310
 311         unp = unp_fp2unpcb(fp);
 312         if (unp != NULL) {
 313                 KASSERT(unp->unp_msgcount > 0,
 314                     ("invalid unp msgcount %d", unp->unp_msgcount));
 315                 unp->unp_msgcount--;
 316                 if (unp->unp_msgcount == 0)
 317                         unp->unp_fp = NULL;
 318         }
 319         fp->f_msgcount--;
 320         unp_rights--;
 321 }
 322
 323 /*
 324  * NOTE: (so) is referenced from soabort*() and netmsg_pru_abort()
 325  *       will sofree() it when we return.
 326  */
 327 static void
 328 uipc_abort(netmsg_t msg)
 329 {
 330         struct unpcb *unp;
 331         int error;
 332
 333         lwkt_gettoken(&unp_token);
 334         unp = unp_getsocktoken(msg->base.nm_so);
 335
 336         if (UNP_ISATTACHED(unp)) {
 337                 unp_drop(unp, ECONNABORTED);
 338                 error = 0;
 339         } else {
 340                 error = EINVAL;
 341         }
 342
 343         unp_reltoken(unp);
 344         lwkt_reltoken(&unp_token);
 345
 346         lwkt_replymsg(&msg->lmsg, error);
 347 }
 348
 349 static void
 350 uipc_accept(netmsg_t msg)
 351 {
 352         struct unpcb *unp;
 353         int error;
 354
 355         lwkt_gettoken(&unp_token);
 356         unp = unp_getsocktoken(msg->base.nm_so);
 357
 358         if (!UNP_ISATTACHED(unp)) {
 359                 error = EINVAL;
 360         } else {
 361                 struct unpcb *unp2 = unp->unp_conn;
 362
 363                 /*
 364                  * Pass back name of connected socket,
 365                  * if it was bound and we are still connected
 366                  * (our peer may have closed already!).
 367                  */
 368                 if (unp2 && unp2->unp_addr) {
 369                         unp_reference(unp2);
 370                         *msg->accept.nm_nam = dup_sockaddr(
 371                                 (struct sockaddr *)unp2->unp_addr);
 372                         unp_free(unp2);
 373                 } else {
 374                         *msg->accept.nm_nam = dup_sockaddr(&sun_noname);
 375                 }
 376                 error = 0;
 377         }
 378
 379         unp_reltoken(unp);
 380         lwkt_reltoken(&unp_token);
 381
 382         lwkt_replymsg(&msg->lmsg, error);
 383 }
 384
 385 static void
 386 uipc_attach(netmsg_t msg)
 387 {
 388         int error;
 389
 390         lwkt_gettoken(&unp_token);
 391
 392         KASSERT(msg->base.nm_so->so_pcb == NULL, ("double unp attach"));
 393         error = unp_attach(msg->base.nm_so, msg->attach.nm_ai);
 394
 395         lwkt_reltoken(&unp_token);
 396         lwkt_replymsg(&msg->lmsg, error);
 397 }
 398
 399 static void
 400 uipc_bind(netmsg_t msg)
 401 {
 402         struct unpcb *unp;
 403         int error;
 404
 405         lwkt_gettoken(&unp_token);
 406         unp = unp_getsocktoken(msg->base.nm_so);
 407
 408         if (UNP_ISATTACHED(unp))
 409                 error = unp_bind(unp, msg->bind.nm_nam, msg->bind.nm_td);
 410         else
 411                 error = EINVAL;
 412
 413         unp_reltoken(unp);
 414         lwkt_reltoken(&unp_token);
 415
 416         lwkt_replymsg(&msg->lmsg, error);
 417 }
 418
 419 static void
 420 uipc_connect(netmsg_t msg)
 421 {
 422         int error;
 423
 424         error = unp_connect(msg->base.nm_so, msg->connect.nm_nam,
 425             msg->connect.nm_td);
 426         lwkt_replymsg(&msg->lmsg, error);
 427 }
 428
 429 static void
 430 uipc_connect2(netmsg_t msg)
 431 {
 432         int error;
 433
 434         error = unp_connect2(msg->connect2.nm_so1, msg->connect2.nm_so2);
 435         lwkt_replymsg(&msg->lmsg, error);
 436 }
 437
 438 /* control is EOPNOTSUPP */
 439
 440 static void
 441 uipc_detach(netmsg_t msg)
 442 {
 443         struct unpcb *unp;
 444         int error;
 445
 446         lwkt_gettoken(&unp_token);
 447         unp = unp_getsocktoken(msg->base.nm_so);
 448
 449         if (UNP_ISATTACHED(unp)) {
 450                 unp_drop(unp, 0);
 451                 error = 0;
 452         } else {
 453                 error = EINVAL;
 454         }
 455
 456         unp_reltoken(unp);
 457         lwkt_reltoken(&unp_token);
 458
 459         lwkt_replymsg(&msg->lmsg, error);
 460 }
 461
 462 static void
 463 uipc_disconnect(netmsg_t msg)
 464 {
 465         struct unpcb *unp;
 466         int error;
 467
 468         lwkt_gettoken(&unp_token);
 469         unp = unp_getsocktoken(msg->base.nm_so);
 470
 471         if (UNP_ISATTACHED(unp)) {
 472                 unp_disconnect(unp, 0);
 473                 error = 0;
 474         } else {
 475                 error = EINVAL;
 476         }
 477
 478         unp_reltoken(unp);
 479         lwkt_reltoken(&unp_token);
 480
 481         lwkt_replymsg(&msg->lmsg, error);
 482 }
 483
 484 static void
 485 uipc_listen(netmsg_t msg)
 486 {
 487         struct unpcb *unp;
 488         int error;
 489
 490         lwkt_gettoken(&unp_token);
 491         unp = unp_getsocktoken(msg->base.nm_so);
 492
 493         if (!UNP_ISATTACHED(unp) || unp->unp_vnode == NULL)
 494                 error = EINVAL;
 495         else
 496                 error = unp_listen(unp, msg->listen.nm_td);
 497
 498         unp_reltoken(unp);
 499         lwkt_reltoken(&unp_token);
 500
 501         lwkt_replymsg(&msg->lmsg, error);
 502 }
 503
 504 static void
 505 uipc_peeraddr(netmsg_t msg)
 506 {
 507         struct unpcb *unp;
 508         int error;
 509
 510         lwkt_gettoken(&unp_token);
 511         unp = unp_getsocktoken(msg->base.nm_so);
 512
 513         if (!UNP_ISATTACHED(unp)) {
 514                 error = EINVAL;
 515         } else if (unp->unp_conn && unp->unp_conn->unp_addr) {
 516                 struct unpcb *unp2 = unp->unp_conn;
 517
 518                 unp_reference(unp2);
 519                 *msg->peeraddr.nm_nam = dup_sockaddr(
 520                                 (struct sockaddr *)unp2->unp_addr);
 521                 unp_free(unp2);
 522                 error = 0;
 523         } else {
 524                 /*
 525                  * XXX: It seems that this test always fails even when
 526                  * connection is established.  So, this else clause is
 527                  * added as workaround to return PF_LOCAL sockaddr.
 528                  */
 529                 *msg->peeraddr.nm_nam = dup_sockaddr(&sun_noname);
 530                 error = 0;
 531         }
 532
 533         unp_reltoken(unp);
 534         lwkt_reltoken(&unp_token);
 535
 536         lwkt_replymsg(&msg->lmsg, error);
 537 }
 538
 539 static void
 540 uipc_rcvd(netmsg_t msg)
 541 {
 542         struct unpcb *unp, *unp2;
 543         struct socket *so;
 544         struct socket *so2;
 545         int error;
 546
 547         /*
 548          * so_pcb is only modified with both the global and the unp
 549          * pool token held.
 550          */
 551         so = msg->base.nm_so;
 552         unp = unp_getsocktoken(so);
 553
 554         if (!UNP_ISATTACHED(unp)) {
 555                 error = EINVAL;
 556                 goto done;
 557         }
 558
 559         switch (so->so_type) {
 560         case SOCK_DGRAM:
 561                 panic("uipc_rcvd DGRAM?");
 562                 /*NOTREACHED*/
 563         case SOCK_STREAM:
 564         case SOCK_SEQPACKET:
 565                 if (unp->unp_conn == NULL)
 566                         break;
 567                 unp2 = unp->unp_conn;   /* protected by pool token */
 568
 569                 /*
 570                  * Because we are transfering mbufs directly to the
 571                  * peer socket we have to use SSB_STOP on the sender
 572                  * to prevent it from building up infinite mbufs.
 573                  *
 574                  * As in several places in this module w ehave to ref unp2
 575                  * to ensure that it does not get ripped out from under us
 576                  * if we block on the so2 token or in sowwakeup().
 577                  */
 578                 so2 = unp2->unp_socket;
 579                 unp_reference(unp2);
 580                 lwkt_gettoken(&so2->so_rcv.ssb_token);
 581                 if (so->so_rcv.ssb_cc < so2->so_snd.ssb_hiwat &&
 582                     so->so_rcv.ssb_mbcnt < so2->so_snd.ssb_mbmax
 583                 ) {
 584                         atomic_clear_int(&so2->so_snd.ssb_flags, SSB_STOP);
 585
 586                         sowwakeup(so2);
 587                 }
 588                 lwkt_reltoken(&so2->so_rcv.ssb_token);
 589                 unp_free(unp2);
 590                 break;
 591         default:
 592                 panic("uipc_rcvd unknown socktype");
 593                 /*NOTREACHED*/
 594         }
 595         error = 0;
 596 done:
 597         unp_reltoken(unp);
 598         lwkt_replymsg(&msg->lmsg, error);
 599 }
 600
 601 /* pru_rcvoob is EOPNOTSUPP */
 602
 603 static void
 604 uipc_send(netmsg_t msg)
 605 {
 606         struct unpcb *unp, *unp2;
 607         struct socket *so;
 608         struct socket *so2;
 609         struct mbuf *control;
 610         struct mbuf *m;
 611         int error = 0;
 612
 613         so = msg->base.nm_so;
 614         control = msg->send.nm_control;
 615         m = msg->send.nm_m;
 616
 617         /*
 618          * so_pcb is only modified with both the global and the unp
 619          * pool token held.
 620          */
 621         so = msg->base.nm_so;
 622         unp = unp_getsocktoken(so);
 623
 624         if (!UNP_ISATTACHED(unp)) {
 625                 error = EINVAL;
 626                 goto release;
 627         }
 628
 629         if (msg->send.nm_flags & PRUS_OOB) {
 630                 error = EOPNOTSUPP;
 631                 goto release;
 632         }
 633
 634         wakeup_start_delayed();
 635
 636         if (control && (error = unp_internalize(control, msg->send.nm_td)))
 637                 goto release;
 638
 639         switch (so->so_type) {
 640         case SOCK_DGRAM:
 641         {
 642                 struct sockaddr *from;
 643
 644                 if (msg->send.nm_addr) {
 645                         if (unp->unp_conn) {
 646                                 error = EISCONN;
 647                                 break;
 648                         }
 649                         lwkt_gettoken(&unp_token);
 650                         error = unp_find_lockref(msg->send.nm_addr,
 651                             msg->send.nm_td, so->so_type, &unp2);
 652                         if (error) {
 653                                 lwkt_reltoken(&unp_token);
 654                                 break;
 655                         }
 656                         /*
 657                          * NOTE:
 658                          * unp2 is locked and referenced.
 659                          *
 660                          * We could unlock unp2 now, since it was checked
 661                          * and referenced.
 662                          */
 663                         unp_reltoken(unp2);
 664                         lwkt_reltoken(&unp_token);
 665                 } else {
 666                         if (unp->unp_conn == NULL) {
 667                                 error = ENOTCONN;
 668                                 break;
 669                         }
 670                         unp2 = unp->unp_conn;
 671                         unp_reference(unp2);
 672                 }
 673                 /* NOTE: unp2 is referenced. */
 674                 so2 = unp2->unp_socket;
 675
 676                 if (unp->unp_addr)
 677                         from = (struct sockaddr *)unp->unp_addr;
 678                 else
 679                         from = &sun_noname;
 680
 681                 lwkt_gettoken(&so2->so_rcv.ssb_token);
 682                 if (ssb_appendaddr(&so2->so_rcv, from, m, control)) {
 683                         sorwakeup(so2);
 684                         m = NULL;
 685                         control = NULL;
 686                 } else {
 687                         error = ENOBUFS;
 688                 }
 689                 lwkt_reltoken(&so2->so_rcv.ssb_token);
 690
 691                 unp_free(unp2);
 692                 break;
 693         }
 694
 695         case SOCK_STREAM:
 696         case SOCK_SEQPACKET:
 697                 /* Connect if not connected yet. */
 698                 /*
 699                  * Note: A better implementation would complain
 700                  * if not equal to the peer's address.
 701                  */
 702                 if (unp->unp_conn == NULL) {
 703                         if (msg->send.nm_addr) {
 704                                 error = unp_connect(so,
 705                                                     msg->send.nm_addr,
 706                                                     msg->send.nm_td);
 707                                 if (error)
 708                                         break;  /* XXX */
 709                         }
 710                         /*
 711                          * NOTE:
 712                          * unp_conn still could be NULL, even if the
 713                          * above unp_connect() succeeds; since the
 714                          * current unp's token could be released due
 715                          * to blocking operations after unp_conn is
 716                          * assigned.
 717                          */
 718                         if (unp->unp_conn == NULL) {
 719                                 error = ENOTCONN;
 720                                 break;
 721                         }
 722                 }
 723                 if (so->so_state & SS_CANTSENDMORE) {
 724                         error = EPIPE;
 725                         break;
 726                 }
 727
 728                 unp2 = unp->unp_conn;
 729                 KASSERT(unp2 != NULL, ("unp is not connected"));
 730                 so2 = unp2->unp_socket;
 731
 732                 unp_reference(unp2);
 733
 734                 /*
 735                  * Send to paired receive port, and then reduce
 736                  * send buffer hiwater marks to maintain backpressure.
 737                  * Wake up readers.
 738                  */
 739                 lwkt_gettoken(&so2->so_rcv.ssb_token);
 740                 if (control) {
 741                         if (ssb_appendcontrol(&so2->so_rcv, m, control)) {
 742                                 control = NULL;
 743                                 m = NULL;
 744                         }
 745                 } else if (so->so_type == SOCK_SEQPACKET) {
 746                         sbappendrecord(&so2->so_rcv.sb, m);
 747                         m = NULL;
 748                 } else {
 749                         sbappend(&so2->so_rcv.sb, m);
 750                         m = NULL;
 751                 }
 752
 753                 /*
 754                  * Because we are transfering mbufs directly to the
 755                  * peer socket we have to use SSB_STOP on the sender
 756                  * to prevent it from building up infinite mbufs.
 757                  */
 758                 if (so2->so_rcv.ssb_cc >= so->so_snd.ssb_hiwat ||
 759                     so2->so_rcv.ssb_mbcnt >= so->so_snd.ssb_mbmax
 760                 ) {
 761                         atomic_set_int(&so->so_snd.ssb_flags, SSB_STOP);
 762                 }
 763                 lwkt_reltoken(&so2->so_rcv.ssb_token);
 764                 sorwakeup(so2);
 765
 766                 unp_free(unp2);
 767                 break;
 768
 769         default:
 770                 panic("uipc_send unknown socktype");
 771         }
 772
 773         /*
 774          * SEND_EOF is equivalent to a SEND followed by a SHUTDOWN.
 775          */
 776         if (msg->send.nm_flags & PRUS_EOF) {
 777                 socantsendmore(so);
 778                 unp_shutdown(unp);
 779         }
 780
 781         if (control && error != 0)
 782                 unp_dispose(control);
 783 release:
 784         unp_reltoken(unp);
 785         wakeup_end_delayed();
 786
 787         if (control)
 788                 m_freem(control);
 789         if (m)
 790                 m_freem(m);
 791         lwkt_replymsg(&msg->lmsg, error);
 792 }
 793
 794 /*
 795  * MPSAFE
 796  */
 797 static void
 798 uipc_sense(netmsg_t msg)
 799 {
 800         struct unpcb *unp;
 801         struct socket *so;
 802         struct stat *sb;
 803         int error;
 804
 805         so = msg->base.nm_so;
 806         sb = msg->sense.nm_stat;
 807
 808         /*
 809          * so_pcb is only modified with both the global and the unp
 810          * pool token held.
 811          */
 812         unp = unp_getsocktoken(so);
 813
 814         if (!UNP_ISATTACHED(unp)) {
 815                 error = EINVAL;
 816                 goto done;
 817         }
 818
 819         sb->st_blksize = so->so_snd.ssb_hiwat;
 820         sb->st_dev = NOUDEV;
 821         if (unp->unp_ino == 0) {        /* make up a non-zero inode number */
 822                 unp->unp_ino = atomic_fetchadd_long(&unp_ino, 1);
 823                 if (__predict_false(unp->unp_ino == 0))
 824                         unp->unp_ino = atomic_fetchadd_long(&unp_ino, 1);
 825         }
 826         sb->st_ino = unp->unp_ino;
 827         error = 0;
 828 done:
 829         unp_reltoken(unp);
 830         lwkt_replymsg(&msg->lmsg, error);
 831 }
 832
 833 static void
 834 uipc_shutdown(netmsg_t msg)
 835 {
 836         struct socket *so;
 837         struct unpcb *unp;
 838         int error;
 839
 840         /*
 841          * so_pcb is only modified with both the global and the unp
 842          * pool token held.
 843          */
 844         so = msg->base.nm_so;
 845         unp = unp_getsocktoken(so);
 846
 847         if (UNP_ISATTACHED(unp)) {
 848                 socantsendmore(so);
 849                 unp_shutdown(unp);
 850                 error = 0;
 851         } else {
 852                 error = EINVAL;
 853         }
 854
 855         unp_reltoken(unp);
 856         lwkt_replymsg(&msg->lmsg, error);
 857 }
 858
 859 static void
 860 uipc_sockaddr(netmsg_t msg)
 861 {
 862         struct unpcb *unp;
 863         int error;
 864
 865         /*
 866          * so_pcb is only modified with both the global and the unp
 867          * pool token held.
 868          */
 869         unp = unp_getsocktoken(msg->base.nm_so);
 870
 871         if (UNP_ISATTACHED(unp)) {
 872                 if (unp->unp_addr) {
 873                         *msg->sockaddr.nm_nam =
 874                                 dup_sockaddr((struct sockaddr *)unp->unp_addr);
 875                 }
 876                 error = 0;
 877         } else {
 878                 error = EINVAL;
 879         }
 880
 881         unp_reltoken(unp);
 882         lwkt_replymsg(&msg->lmsg, error);
 883 }
 884
 885 struct pr_usrreqs uipc_usrreqs = {
 886         .pru_abort = uipc_abort,
 887         .pru_accept = uipc_accept,
 888         .pru_attach = uipc_attach,
 889         .pru_bind = uipc_bind,
 890         .pru_connect = uipc_connect,
 891         .pru_connect2 = uipc_connect2,
 892         .pru_control = pr_generic_notsupp,
 893         .pru_detach = uipc_detach,
 894         .pru_disconnect = uipc_disconnect,
 895         .pru_listen = uipc_listen,
 896         .pru_peeraddr = uipc_peeraddr,
 897         .pru_rcvd = uipc_rcvd,
 898         .pru_rcvoob = pr_generic_notsupp,
 899         .pru_send = uipc_send,
 900         .pru_sense = uipc_sense,
 901         .pru_shutdown = uipc_shutdown,
 902         .pru_sockaddr = uipc_sockaddr,
 903         .pru_sosend = sosend,
 904         .pru_soreceive = soreceive
 905 };
 906
 907 void
 908 uipc_ctloutput(netmsg_t msg)
 909 {
 910         struct socket *so;
 911         struct sockopt *sopt;
 912         struct unpcb *unp;
 913         int error = 0;
 914
 915         so = msg->base.nm_so;
 916         sopt = msg->ctloutput.nm_sopt;
 917
 918         lwkt_gettoken(&unp_token);
 919         unp = unp_getsocktoken(so);
 920
 921         if (!UNP_ISATTACHED(unp)) {
 922                 error = EINVAL;
 923                 goto done;
 924         }
 925
 926         switch (sopt->sopt_dir) {
 927         case SOPT_GET:
 928                 switch (sopt->sopt_name) {
 929                 case LOCAL_PEERCRED:
 930                         if (unp->unp_flags & UNP_HAVEPC)
 931                                 soopt_from_kbuf(sopt, &unp->unp_peercred,
 932                                                 sizeof(unp->unp_peercred));
 933                         else {
 934                                 if (so->so_type == SOCK_STREAM)
 935                                         error = ENOTCONN;
 936                                 else if (so->so_type == SOCK_SEQPACKET)
 937                                         error = ENOTCONN;
 938                                 else
 939                                         error = EINVAL;
 940                         }
 941                         break;
 942                 default:
 943                         error = EOPNOTSUPP;
 944                         break;
 945                 }
 946                 break;
 947         case SOPT_SET:
 948         default:
 949                 error = EOPNOTSUPP;
 950                 break;
 951         }
 952
 953 done:
 954         unp_reltoken(unp);
 955         lwkt_reltoken(&unp_token);
 956
 957         lwkt_replymsg(&msg->lmsg, error);
 958 }
 959
 960 /*
 961  * Both send and receive buffers are allocated PIPSIZ bytes of buffering
 962  * for stream sockets, although the total for sender and receiver is
 963  * actually only PIPSIZ.
 964  *
 965  * Datagram sockets really use the sendspace as the maximum datagram size,
 966  * and don't really want to reserve the sendspace.  Their recvspace should
 967  * be large enough for at least one max-size datagram plus address.
 968  *
 969  * We want the local send/recv space to be significant larger then lo0's
 970  * mtu of 16384.
 971  */
 972 #ifndef PIPSIZ
 973 #define PIPSIZ  57344
 974 #endif
 975 static u_long   unpst_sendspace = PIPSIZ;
 976 static u_long   unpst_recvspace = PIPSIZ;
 977 static u_long   unpdg_sendspace = 2*1024;       /* really max datagram size */
 978 static u_long   unpdg_recvspace = 4*1024;
 979
 980 SYSCTL_DECL(_net_local_seqpacket);
 981 SYSCTL_DECL(_net_local_stream);
 982 SYSCTL_INT(_net_local_stream, OID_AUTO, sendspace, CTLFLAG_RW,
 983     &unpst_sendspace, 0, "Size of stream socket send buffer");
 984 SYSCTL_INT(_net_local_stream, OID_AUTO, recvspace, CTLFLAG_RW,
 985     &unpst_recvspace, 0, "Size of stream socket receive buffer");
 986
 987 SYSCTL_DECL(_net_local_dgram);
 988 SYSCTL_INT(_net_local_dgram, OID_AUTO, maxdgram, CTLFLAG_RW,
 989     &unpdg_sendspace, 0, "Max datagram socket size");
 990 SYSCTL_INT(_net_local_dgram, OID_AUTO, recvspace, CTLFLAG_RW,
 991     &unpdg_recvspace, 0, "Size of datagram socket receive buffer");
 992
 993 static int
 994 unp_attach(struct socket *so, struct pru_attach_info *ai)
 995 {
 996         struct unp_global_head *head;
 997         struct unpcb *unp;
 998         int error;
 999
1000         lwkt_gettoken(&unp_token);
1001
1002         if (so->so_snd.ssb_hiwat == 0 || so->so_rcv.ssb_hiwat == 0) {
1003                 switch (so->so_type) {
1004                 case SOCK_STREAM:
1005                 case SOCK_SEQPACKET:
1006                         error = soreserve(so, unpst_sendspace, unpst_recvspace,
1007                                           ai->sb_rlimit);
1008                         break;
1009
1010                 case SOCK_DGRAM:
1011                         error = soreserve(so, unpdg_sendspace, unpdg_recvspace,
1012                                           ai->sb_rlimit);
1013                         break;
1014
1015                 default:
1016                         panic("unp_attach");
1017                 }
1018                 if (error)
1019                         goto failed;
1020         }
1021
1022         /*
1023          * In order to support sendfile we have to set either SSB_STOPSUPP
1024          * or SSB_PREALLOC.  Unix domain sockets use the SSB_STOP flow
1025          * control mechanism.
1026          */
1027         if (so->so_type == SOCK_STREAM) {
1028                 atomic_set_int(&so->so_rcv.ssb_flags, SSB_STOPSUPP);
1029                 atomic_set_int(&so->so_snd.ssb_flags, SSB_STOPSUPP);
1030         }
1031
1032         unp = kmalloc(sizeof(*unp), M_UNPCB, M_WAITOK | M_ZERO | M_NULLOK);
1033         if (unp == NULL) {
1034                 error = ENOBUFS;
1035                 goto failed;
1036         }
1037         unp->unp_refcnt = 1;
1038         unp->unp_gencnt = ++unp_gencnt;
1039         LIST_INIT(&unp->unp_refs);
1040         unp->unp_socket = so;
1041         unp->unp_rvnode = ai->fd_rdir;          /* jail cruft XXX JH */
1042         so->so_pcb = (caddr_t)unp;
1043         soreference(so);
1044
1045         head = unp_globalhead(so->so_type);
1046         TAILQ_INSERT_TAIL(&head->list, unp, unp_link);
1047         head->count++;
1048         error = 0;
1049 failed:
1050         lwkt_reltoken(&unp_token);
1051         return error;
1052 }
1053
1054 static void
1055 unp_detach(struct unpcb *unp)
1056 {
1057         struct socket *so;
1058
1059         lwkt_gettoken(&unp_token);
1060         lwkt_getpooltoken(unp);
1061
1062         so = unp->unp_socket;
1063
1064         unp->unp_gencnt = ++unp_gencnt;
1065         if (unp->unp_vnode) {
1066                 unp->unp_vnode->v_socket = NULL;
1067                 vrele(unp->unp_vnode);
1068                 unp->unp_vnode = NULL;
1069         }
1070         soisdisconnected(so);
1071         KKASSERT(so->so_pcb == unp);
1072         so->so_pcb = NULL;              /* both tokens required */
1073         unp->unp_socket = NULL;
1074
1075         lwkt_relpooltoken(unp);
1076         lwkt_reltoken(&unp_token);
1077
1078         sofree(so);
1079
1080         KASSERT(unp->unp_conn == NULL, ("unp is still connected"));
1081         KASSERT(LIST_EMPTY(&unp->unp_refs), ("unp still has references"));
1082
1083         if (unp->unp_addr)
1084                 kfree(unp->unp_addr, M_SONAME);
1085         kfree(unp, M_UNPCB);
1086
1087         if (unp_rights)
1088                 taskqueue_enqueue(unp_taskqueue, &unp_gc_task);
1089 }
1090
1091 static int
1092 unp_bind(struct unpcb *unp, struct sockaddr *nam, struct thread *td)
1093 {
1094         struct proc *p = td->td_proc;
1095         struct sockaddr_un *soun = (struct sockaddr_un *)nam;
1096         struct vnode *vp;
1097         struct vattr vattr;
1098         int error, namelen;
1099         struct nlookupdata nd;
1100         char buf[SOCK_MAXADDRLEN];
1101
1102         ASSERT_LWKT_TOKEN_HELD(&unp_token);
1103         UNP_ASSERT_TOKEN_HELD(unp);
1104
1105         if (unp->unp_vnode != NULL)
1106                 return EINVAL;
1107
1108         namelen = soun->sun_len - offsetof(struct sockaddr_un, sun_path);
1109         if (namelen <= 0)
1110                 return EINVAL;
1111         strncpy(buf, soun->sun_path, namelen);
1112         buf[namelen] = 0;       /* null-terminate the string */
1113         error = nlookup_init(&nd, buf, UIO_SYSSPACE,
1114                              NLC_LOCKVP | NLC_CREATE | NLC_REFDVP);
1115         if (error == 0)
1116                 error = nlookup(&nd);
1117         if (error == 0 && nd.nl_nch.ncp->nc_vp != NULL)
1118                 error = EADDRINUSE;
1119         if (error)
1120                 goto done;
1121
1122         VATTR_NULL(&vattr);
1123         vattr.va_type = VSOCK;
1124         vattr.va_mode = (ACCESSPERMS & ~p->p_fd->fd_cmask);
1125         error = VOP_NCREATE(&nd.nl_nch, nd.nl_dvp, &vp, nd.nl_cred, &vattr);
1126         if (error == 0) {
1127                 if (unp->unp_vnode == NULL) {
1128                         vp->v_socket = unp->unp_socket;
1129                         unp->unp_vnode = vp;
1130                         unp->unp_addr = (struct sockaddr_un *)dup_sockaddr(nam);
1131                         vn_unlock(vp);
1132                 } else {
1133                         vput(vp);               /* late race */
1134                         error = EINVAL;
1135                 }
1136         }
1137 done:
1138         nlookup_done(&nd);
1139         return (error);
1140 }
1141
1142 static int
1143 unp_connect(struct socket *so, struct sockaddr *nam, struct thread *td)
1144 {
1145         struct unpcb *unp, *unp2;
1146         int error, flags = 0;
1147
1148         lwkt_gettoken(&unp_token);
1149
1150         unp = unp_getsocktoken(so);
1151         if (!UNP_ISATTACHED(unp)) {
1152                 error = EINVAL;
1153                 goto failed;
1154         }
1155
1156         if ((unp->unp_flags & UNP_CONNECTING) || unp->unp_conn != NULL) {
1157                 error = EISCONN;
1158                 goto failed;
1159         }
1160
1161         flags = UNP_CONNECTING;
1162         unp_setflags(unp, flags);
1163
1164         error = unp_find_lockref(nam, td, so->so_type, &unp2);
1165         if (error)
1166                 goto failed;
1167         /*
1168          * NOTE:
1169          * unp2 is locked and referenced.
1170          */
1171
1172         if (so->so_proto->pr_flags & PR_CONNREQUIRED) {
1173                 struct socket *so2, *so3;
1174                 struct unpcb *unp3;
1175
1176                 so2 = unp2->unp_socket;
1177                 if (!(so2->so_options & SO_ACCEPTCONN) ||
1178                     (so3 = sonewconn_faddr(so2, 0, NULL,
1179                      TRUE /* keep ref */)) == NULL) {
1180                         error = ECONNREFUSED;
1181                         goto done;
1182                 }
1183                 /* so3 has a socket reference. */
1184
1185                 unp3 = unp_getsocktoken(so3);
1186                 if (!UNP_ISATTACHED(unp3)) {
1187                         unp_reltoken(unp3);
1188                         /*
1189                          * Already aborted; we only need to drop the
1190                          * socket reference held by sonewconn_faddr().
1191                          */
1192                         sofree(so3);
1193                         error = ECONNREFUSED;
1194                         goto done;
1195                 }
1196                 unp_reference(unp3);
1197                 /*
1198                  * NOTE:
1199                  * unp3 is locked and referenced.
1200                  */
1201
1202                 /*
1203                  * Release so3 socket reference held by sonewconn_faddr().
1204                  * Since we have referenced unp3, neither unp3 nor so3 will
1205                  * be destroyed here.
1206                  */
1207                 sofree(so3);
1208
1209                 if (unp2->unp_addr != NULL) {
1210                         unp3->unp_addr = (struct sockaddr_un *)
1211                             dup_sockaddr((struct sockaddr *)unp2->unp_addr);
1212                 }
1213
1214                 /*
1215                  * unp_peercred management:
1216                  *
1217                  * The connecter's (client's) credentials are copied
1218                  * from its process structure at the time of connect()
1219                  * (which is now).
1220                  */
1221                 cru2x(td->td_proc->p_ucred, &unp3->unp_peercred);
1222                 unp_setflags(unp3, UNP_HAVEPC);
1223                 /*
1224                  * The receiver's (server's) credentials are copied
1225                  * from the unp_peercred member of socket on which the
1226                  * former called listen(); unp_listen() cached that
1227                  * process's credentials at that time so we can use
1228                  * them now.
1229                  */
1230                 KASSERT(unp2->unp_flags & UNP_HAVEPCCACHED,
1231                     ("unp_connect: listener without cached peercred"));
1232                 memcpy(&unp->unp_peercred, &unp2->unp_peercred,
1233                     sizeof(unp->unp_peercred));
1234                 unp_setflags(unp, UNP_HAVEPC);
1235
1236                 error = unp_connect_pair(unp, unp3);
1237                 if (error)
1238                         soabort_direct(so3);
1239
1240                 /* Done with unp3 */
1241                 unp_free(unp3);
1242                 unp_reltoken(unp3);
1243         } else {
1244                 error = unp_connect_pair(unp, unp2);
1245         }
1246 done:
1247         unp_free(unp2);
1248         unp_reltoken(unp2);
1249 failed:
1250         if (flags)
1251                 unp_clrflags(unp, flags);
1252         unp_reltoken(unp);
1253
1254         lwkt_reltoken(&unp_token);
1255         return (error);
1256 }
1257
1258 /*
1259  * Connect two unix domain sockets together.
1260  *
1261  * NOTE: Semantics for any change to unp_conn requires that the per-unp
1262  *       pool token also be held.
1263  */
1264 int
1265 unp_connect2(struct socket *so, struct socket *so2)
1266 {
1267         struct unpcb *unp, *unp2;
1268         int error;
1269
1270         lwkt_gettoken(&unp_token);
1271         if (so2->so_type != so->so_type) {
1272                 lwkt_reltoken(&unp_token);
1273                 return (EPROTOTYPE);
1274         }
1275         unp = unp_getsocktoken(so);
1276         unp2 = unp_getsocktoken(so2);
1277
1278         if (!UNP_ISATTACHED(unp)) {
1279                 error = EINVAL;
1280                 goto done;
1281         }
1282         if (!UNP_ISATTACHED(unp2)) {
1283                 error = ECONNREFUSED;
1284                 goto done;
1285         }
1286
1287         if (unp->unp_conn != NULL) {
1288                 error = EISCONN;
1289                 goto done;
1290         }
1291         if ((so->so_type == SOCK_STREAM || so->so_type == SOCK_SEQPACKET) &&
1292             unp2->unp_conn != NULL) {
1293                 error = EISCONN;
1294                 goto done;
1295         }
1296
1297         error = unp_connect_pair(unp, unp2);
1298 done:
1299         unp_reltoken(unp2);
1300         unp_reltoken(unp);
1301         lwkt_reltoken(&unp_token);
1302         return (error);
1303 }
1304
1305 /*
1306  * Disconnect a unix domain socket pair.
1307  *
1308  * NOTE: Semantics for any change to unp_conn requires that the per-unp
1309  *       pool token also be held.
1310  */
1311 static void
1312 unp_disconnect(struct unpcb *unp, int error)
1313 {
1314         struct socket *so = unp->unp_socket;
1315         struct unpcb *unp2;
1316
1317         ASSERT_LWKT_TOKEN_HELD(&unp_token);
1318         UNP_ASSERT_TOKEN_HELD(unp);
1319
1320         if (error)
1321                 so->so_error = error;
1322
1323         while ((unp2 = unp->unp_conn) != NULL) {
1324                 lwkt_getpooltoken(unp2);
1325                 if (unp2 == unp->unp_conn)
1326                         break;
1327                 lwkt_relpooltoken(unp2);
1328         }
1329         if (unp2 == NULL)
1330                 return;
1331         /* unp2 is locked. */
1332
1333         KASSERT((unp2->unp_flags & UNP_DROPPED) == 0, ("unp2 was dropped"));
1334
1335         unp->unp_conn = NULL;
1336
1337         switch (so->so_type) {
1338         case SOCK_DGRAM:
1339                 LIST_REMOVE(unp, unp_reflink);
1340                 soclrstate(so, SS_ISCONNECTED);
1341                 break;
1342
1343         case SOCK_STREAM:
1344         case SOCK_SEQPACKET:
1345                 /*
1346                  * Keep a reference before clearing the unp_conn
1347                  * to avoid racing uipc_detach()/uipc_abort() in
1348                  * other thread.
1349                  */
1350                 unp_reference(unp2);
1351                 KASSERT(unp2->unp_conn == unp, ("unp_conn mismatch"));
1352                 unp2->unp_conn = NULL;
1353
1354                 soisdisconnected(so);
1355                 soisdisconnected(unp2->unp_socket);
1356
1357                 unp_free(unp2);
1358                 break;
1359         }
1360
1361         lwkt_relpooltoken(unp2);
1362 }
1363
1364 #ifdef notdef
1365 void
1366 unp_abort(struct unpcb *unp)
1367 {
1368         lwkt_gettoken(&unp_token);
1369         unp_free(unp);
1370         lwkt_reltoken(&unp_token);
1371 }
1372 #endif
1373
1374 static int
1375 prison_unpcb(struct thread *td, struct unpcb *unp)
1376 {
1377         struct proc *p;
1378
1379         if (td == NULL)
1380                 return (0);
1381         if ((p = td->td_proc) == NULL)
1382                 return (0);
1383         if (!p->p_ucred->cr_prison)
1384                 return (0);
1385         if (p->p_fd->fd_rdir == unp->unp_rvnode)
1386                 return (0);
1387         return (1);
1388 }
1389
1390 static int
1391 unp_pcblist(SYSCTL_HANDLER_ARGS)
1392 {
1393         struct unp_global_head *head = arg1;
1394         int error, i, n;
1395         struct unpcb *unp, *marker;
1396
1397         KKASSERT(curproc != NULL);
1398
1399         /*
1400          * The process of preparing the PCB list is too time-consuming and
1401          * resource-intensive to repeat twice on every request.
1402          */
1403         if (req->oldptr == NULL) {
1404                 n = head->count;
1405                 req->oldidx = (n + n/8) * sizeof(struct xunpcb);
1406                 return 0;
1407         }
1408
1409         if (req->newptr != NULL)
1410                 return EPERM;
1411
1412         marker = kmalloc(sizeof(*marker), M_UNPCB, M_WAITOK | M_ZERO);
1413         marker->unp_flags |= UNP_MARKER;
1414
1415         lwkt_gettoken(&unp_token);
1416
1417         n = head->count;
1418         i = 0;
1419         error = 0;
1420
1421         TAILQ_INSERT_HEAD(&head->list, marker, unp_link);
1422         while ((unp = TAILQ_NEXT(marker, unp_link)) != NULL && i < n) {
1423                 struct xunpcb xu;
1424
1425                 TAILQ_REMOVE(&head->list, marker, unp_link);
1426                 TAILQ_INSERT_AFTER(&head->list, unp, marker, unp_link);
1427
1428                 if (unp->unp_flags & UNP_MARKER)
1429                         continue;
1430                 if (prison_unpcb(req->td, unp))
1431                         continue;
1432
1433                 xu.xu_len = sizeof(xu);
1434                 xu.xu_unpp = unp;
1435
1436                 /*
1437                  * NOTE:
1438                  * unp->unp_addr and unp->unp_conn are protected by
1439                  * unp_token.  So if we want to get rid of unp_token
1440                  * or reduce the coverage of unp_token, care must be
1441                  * taken.
1442                  */
1443                 if (unp->unp_addr) {
1444                         bcopy(unp->unp_addr, &xu.xu_addr,
1445                               unp->unp_addr->sun_len);
1446                 }
1447                 if (unp->unp_conn && unp->unp_conn->unp_addr) {
1448                         bcopy(unp->unp_conn->unp_addr,
1449                               &xu.xu_caddr,
1450                               unp->unp_conn->unp_addr->sun_len);
1451                 }
1452                 bcopy(unp, &xu.xu_unp, sizeof(*unp));
1453                 sotoxsocket(unp->unp_socket, &xu.xu_socket);
1454
1455                 /* NOTE: This could block and temporarily release unp_token */
1456                 error = SYSCTL_OUT(req, &xu, sizeof(xu));
1457                 if (error)
1458                         break;
1459                 ++i;
1460         }
1461         TAILQ_REMOVE(&head->list, marker, unp_link);
1462
1463         lwkt_reltoken(&unp_token);
1464
1465         kfree(marker, M_UNPCB);
1466         return error;
1467 }
1468
1469 SYSCTL_PROC(_net_local_dgram, OID_AUTO, pcblist, CTLFLAG_RD,
1470             &unp_dgram_head, 0, unp_pcblist, "S,xunpcb",
1471             "List of active local datagram sockets");
1472 SYSCTL_PROC(_net_local_stream, OID_AUTO, pcblist, CTLFLAG_RD,
1473             &unp_stream_head, 0, unp_pcblist, "S,xunpcb",
1474             "List of active local stream sockets");
1475 SYSCTL_PROC(_net_local_seqpacket, OID_AUTO, pcblist, CTLFLAG_RD,
1476             &unp_seqpkt_head, 0, unp_pcblist, "S,xunpcb",
1477             "List of active local seqpacket sockets");
1478
1479 static void
1480 unp_shutdown(struct unpcb *unp)
1481 {
1482         struct socket *so;
1483
1484         if ((unp->unp_socket->so_type == SOCK_STREAM ||
1485              unp->unp_socket->so_type == SOCK_SEQPACKET) &&
1486             unp->unp_conn != NULL && (so = unp->unp_conn->unp_socket)) {
1487                 socantrcvmore(so);
1488         }
1489 }
1490
1491 #ifdef notdef
1492 void
1493 unp_drain(void)
1494 {
1495         lwkt_gettoken(&unp_token);
1496         lwkt_reltoken(&unp_token);
1497 }
1498 #endif
1499
1500 int
1501 unp_externalize(struct mbuf *rights, int flags)
1502 {
1503         struct thread *td = curthread;
1504         struct proc *p = td->td_proc;           /* XXX */
1505         struct lwp *lp = td->td_lwp;
1506         struct cmsghdr *cm = mtod(rights, struct cmsghdr *);
1507         int *fdp;
1508         int i;
1509         struct file **rp;
1510         struct file *fp;
1511         int newfds = (cm->cmsg_len - (CMSG_DATA(cm) - (u_char *)cm))
1512                 / sizeof(struct file *);
1513         int f;
1514
1515         lwkt_gettoken(&unp_rights_token);
1516
1517         /*
1518          * if the new FD's will not fit, then we free them all
1519          */
1520         if (!fdavail(p, newfds)) {
1521                 rp = (struct file **)CMSG_DATA(cm);
1522                 for (i = 0; i < newfds; i++) {
1523                         fp = *rp;
1524                         /*
1525                          * zero the pointer before calling unp_discard,
1526                          * since it may end up in unp_gc()..
1527                          */
1528                         *rp++ = NULL;
1529                         unp_discard(fp, NULL);
1530                 }
1531                 lwkt_reltoken(&unp_rights_token);
1532                 return (EMSGSIZE);
1533         }
1534
1535         /*
1536          * now change each pointer to an fd in the global table to
1537          * an integer that is the index to the local fd table entry
1538          * that we set up to point to the global one we are transferring.
1539          * Since the sizeof(struct file *) is bigger than or equal to
1540          * the sizeof(int), we do it in forward order.  In that case,
1541          * an integer will always come in the same place or before its
1542          * corresponding struct file pointer.
1543          *
1544          * Hold revoke_token in 'shared' mode, so that we won't miss
1545          * the FREVOKED update on fps being externalized (fsetfd).
1546          */
1547         lwkt_gettoken_shared(&revoke_token);
1548         fdp = (int *)CMSG_DATA(cm);
1549         rp = (struct file **)CMSG_DATA(cm);
1550         for (i = 0; i < newfds; i++) {
1551                 if (fdalloc(p, 0, &f)) {
1552                         int j;
1553
1554                         /*
1555                          * Previous fdavail() can't garantee
1556                          * fdalloc() success due to SMP race.
1557                          * Just clean up and return the same
1558                          * error value as if fdavail() failed.
1559                          */
1560                         lwkt_reltoken(&revoke_token);
1561
1562                         /* Close externalized files */
1563                         for (j = 0; j < i; j++)
1564                                 kern_close(fdp[j]);
1565                         /* Discard the rest of internal files */
1566                         for (; i < newfds; i++)
1567                                 unp_discard(rp[i], NULL);
1568                         /* Wipe out the control message */
1569                         for (i = 0; i < newfds; i++)
1570                                 rp[i] = NULL;
1571
1572                         lwkt_reltoken(&unp_rights_token);
1573                         return (EMSGSIZE);
1574                 }
1575                 fp = rp[i];
1576                 unp_fp_externalize(lp, fp, f, flags);
1577                 fdp[i] = f;
1578         }
1579         lwkt_reltoken(&revoke_token);
1580
1581         lwkt_reltoken(&unp_rights_token);
1582
1583         /*
1584          * Adjust length, in case sizeof(struct file *) and sizeof(int)
1585          * differs.
1586          */
1587         cm->cmsg_len = CMSG_LEN(newfds * sizeof(int));
1588         rights->m_len = cm->cmsg_len;
1589
1590         return (0);
1591 }
1592
1593 static void
1594 unp_fp_externalize(struct lwp *lp, struct file *fp, int fd, int flags)
1595 {
1596         if (lp) {
1597                 struct filedesc *fdp = lp->lwp_proc->p_fd;
1598
1599                 KKASSERT(fd >= 0);
1600                 if (fp->f_flag & FREVOKED) {
1601                         struct file *fx;
1602                         int error;
1603
1604                         kprintf("Warning: revoked fp exiting unix socket\n");
1605                         error = falloc(lp, &fx, NULL);
1606                         if (error == 0) {
1607                                 if (flags & MSG_CMSG_CLOEXEC)
1608                                         fdp->fd_files[fd].fileflags |= UF_EXCLOSE;
1609                                 fsetfd(fdp, fx, fd);
1610                                 fdrop(fx);
1611                         } else {
1612                                 fsetfd(fdp, NULL, fd);
1613                         }
1614                 } else {
1615                         if (flags & MSG_CMSG_CLOEXEC)
1616                                 fdp->fd_files[fd].fileflags |= UF_EXCLOSE;
1617                         fsetfd(fdp, fp, fd);
1618                 }
1619         }
1620         unp_del_right(fp);
1621         fdrop(fp);
1622 }
1623
1624 void
1625 unp_init(void)
1626 {
1627         TAILQ_INIT(&unp_stream_head.list);
1628         TAILQ_INIT(&unp_dgram_head.list);
1629         TAILQ_INIT(&unp_seqpkt_head.list);
1630
1631         SLIST_INIT(&unp_defdiscard_head);
1632         spin_init(&unp_defdiscard_spin, "unpdisc");
1633         TASK_INIT(&unp_defdiscard_task, 0, unp_defdiscard_taskfunc, NULL);
1634
1635         /*
1636          * This implies that only one gc can be in-progress at any
1637          * given moment.
1638          */
1639         TASK_INIT(&unp_gc_task, 0, unp_gc, NULL);
1640
1641         unp_gc_marker = kmalloc(sizeof(*unp_gc_marker), M_UNPCB,
1642             M_WAITOK | M_ZERO);
1643         unp_gc_marker->unp_flags |= UNP_MARKER;
1644
1645         /*
1646          * Create taskqueue for defered discard, and stick it to
1647          * the last CPU.
1648          */
1649         unp_taskqueue = taskqueue_create("unp_taskq", M_WAITOK,
1650             taskqueue_thread_enqueue, &unp_taskqueue);
1651         taskqueue_start_threads(&unp_taskqueue, 1, TDPRI_KERN_DAEMON,
1652             ncpus - 1, "unp taskq");
1653 }
1654
1655 static int
1656 unp_internalize(struct mbuf *control, struct thread *td)
1657 {
1658         struct proc *p = td->td_proc;
1659         struct filedesc *fdescp;
1660         struct cmsghdr *cm = mtod(control, struct cmsghdr *);
1661         struct file **rp;
1662         struct file *fp;
1663         int i, fd, *fdp;
1664         struct cmsgcred *cmcred;
1665         int oldfds;
1666         u_int newlen;
1667         int error;
1668
1669         KKASSERT(p);
1670
1671         if ((cm->cmsg_type != SCM_RIGHTS && cm->cmsg_type != SCM_CREDS) ||
1672             cm->cmsg_level != SOL_SOCKET ||
1673             CMSG_ALIGN(cm->cmsg_len) != control->m_len)
1674                 return EINVAL;
1675
1676         /*
1677          * Fill in credential information.
1678          */
1679         if (cm->cmsg_type == SCM_CREDS) {
1680                 cmcred = (struct cmsgcred *)CMSG_DATA(cm);
1681                 cmcred->cmcred_pid = p->p_pid;
1682                 cmcred->cmcred_uid = p->p_ucred->cr_ruid;
1683                 cmcred->cmcred_gid = p->p_ucred->cr_rgid;
1684                 cmcred->cmcred_euid = p->p_ucred->cr_uid;
1685                 cmcred->cmcred_ngroups = MIN(p->p_ucred->cr_ngroups,
1686                                                         CMGROUP_MAX);
1687                 for (i = 0; i < cmcred->cmcred_ngroups; i++)
1688                         cmcred->cmcred_groups[i] = p->p_ucred->cr_groups[i];
1689                 return 0;
1690         }
1691
1692         /*
1693          * cmsghdr may not be aligned, do not allow calculation(s) to
1694          * go negative.
1695          */
1696         if (cm->cmsg_len < CMSG_LEN(0))
1697                 return EINVAL;
1698
1699         oldfds = (cm->cmsg_len - CMSG_LEN(0)) / sizeof(int);
1700
1701         /*
1702          * Now replace the integer FDs with pointers to
1703          * the associated global file table entry..
1704          * Allocate a bigger buffer as necessary. But if an cluster is not
1705          * enough, return E2BIG.
1706          */
1707         newlen = CMSG_LEN(oldfds * sizeof(struct file *));
1708         if (newlen > MCLBYTES)
1709                 return E2BIG;
1710         if (newlen - control->m_len > M_TRAILINGSPACE(control)) {
1711                 if (control->m_flags & M_EXT)
1712                         return E2BIG;
1713                 MCLGET(control, M_WAITOK);
1714                 if (!(control->m_flags & M_EXT))
1715                         return ENOBUFS;
1716
1717                 /* copy the data to the cluster */
1718                 memcpy(mtod(control, char *), cm, cm->cmsg_len);
1719                 cm = mtod(control, struct cmsghdr *);
1720         }
1721
1722         lwkt_gettoken(&unp_rights_token);
1723
1724         fdescp = p->p_fd;
1725         spin_lock_shared(&fdescp->fd_spin);
1726
1727         /*
1728          * check that all the FDs passed in refer to legal OPEN files
1729          * If not, reject the entire operation.
1730          */
1731         fdp = (int *)CMSG_DATA(cm);
1732         for (i = 0; i < oldfds; i++) {
1733                 fd = *fdp++;
1734                 if ((unsigned)fd >= fdescp->fd_nfiles ||
1735                     fdescp->fd_files[fd].fp == NULL) {
1736                         error = EBADF;
1737                         goto done;
1738                 }
1739                 if (fdescp->fd_files[fd].fp->f_type == DTYPE_KQUEUE) {
1740                         error = EOPNOTSUPP;
1741                         goto done;
1742                 }
1743         }
1744
1745         /*
1746          * Adjust length, in case sizeof(struct file *) and sizeof(int)
1747          * differs.
1748          */
1749         cm->cmsg_len = newlen;
1750         control->m_len = CMSG_ALIGN(newlen);
1751
1752         /*
1753          * Transform the file descriptors into struct file pointers.
1754          * Since the sizeof(struct file *) is bigger than or equal to
1755          * the sizeof(int), we do it in reverse order so that the int
1756          * won't get trashed until we're done.
1757          */
1758         fdp = (int *)CMSG_DATA(cm) + oldfds - 1;
1759         rp = (struct file **)CMSG_DATA(cm) + oldfds - 1;
1760         for (i = 0; i < oldfds; i++) {
1761                 fp = fdescp->fd_files[*fdp--].fp;
1762                 *rp-- = fp;
1763                 fhold(fp);
1764                 unp_add_right(fp);
1765         }
1766         error = 0;
1767 done:
1768         spin_unlock_shared(&fdescp->fd_spin);
1769         lwkt_reltoken(&unp_rights_token);
1770         return error;
1771 }
1772
1773 #ifdef UNP_GC_ALLFILES
1774
1775 /*
1776  * Garbage collect in-transit file descriptors that get lost due to
1777  * loops (i.e. when a socket is sent to another process over itself,
1778  * and more complex situations).
1779  *
1780  * NOT MPSAFE - TODO socket flush code and maybe fdrop.  Rest is MPSAFE.
1781  */
1782
1783 struct unp_gc_info {
1784         struct file **extra_ref;
1785         struct file *locked_fp;
1786         int defer;
1787         int index;
1788         int maxindex;
1789 };
1790
1791 static void
1792 unp_gc(void *arg __unused, int pending __unused)
1793 {
1794         struct unp_gc_info info;
1795         struct file **fpp;
1796         int i;
1797
1798         lwkt_gettoken(&unp_rights_token);
1799
1800         /*
1801          * Before going through all this, set all FDs to be NOT defered
1802          * and NOT externally accessible (not marked).  During the scan
1803          * a fd can be marked externally accessible but we may or may not
1804          * be able to immediately process it (controlled by FDEFER).
1805          *
1806          * If we loop sleep a bit.  The complexity of the topology can cause
1807          * multiple loops.  Also failure to acquire the socket's so_rcv
1808          * token can cause us to loop.
1809          */
1810         allfiles_scan_exclusive(unp_gc_clearmarks, NULL);
1811         do {
1812                 info.defer = 0;
1813                 allfiles_scan_exclusive(unp_gc_checkmarks, &info);
1814                 if (info.defer)
1815                         tsleep(&info, 0, "gcagain", 1);
1816         } while (info.defer);
1817
1818         /*
1819          * We grab an extra reference to each of the file table entries
1820          * that are not otherwise accessible and then free the rights
1821          * that are stored in messages on them.
1822          *
1823          * The bug in the orginal code is a little tricky, so I'll describe
1824          * what's wrong with it here.
1825          *
1826          * It is incorrect to simply unp_discard each entry for f_msgcount
1827          * times -- consider the case of sockets A and B that contain
1828          * references to each other.  On a last close of some other socket,
1829          * we trigger a gc since the number of outstanding rights (unp_rights)
1830          * is non-zero.  If during the sweep phase the gc code unp_discards,
1831          * we end up doing a (full) fdrop on the descriptor.  A fdrop on A
1832          * results in the following chain.  Closef calls soo_close, which
1833          * calls soclose.   Soclose calls first (through the switch
1834          * uipc_usrreq) unp_detach, which re-invokes unp_gc.  Unp_gc simply
1835          * returns because the previous instance had set unp_gcing, and
1836          * we return all the way back to soclose, which marks the socket
1837          * with SS_NOFDREF, and then calls sofree.  Sofree calls sorflush
1838          * to free up the rights that are queued in messages on the socket A,
1839          * i.e., the reference on B.  The sorflush calls via the dom_dispose
1840          * switch unp_dispose, which unp_scans with unp_discard.  This second
1841          * instance of unp_discard just calls fdrop on B.
1842          *
1843          * Well, a similar chain occurs on B, resulting in a sorflush on B,
1844          * which results in another fdrop on A.  Unfortunately, A is already
1845          * being closed, and the descriptor has already been marked with
1846          * SS_NOFDREF, and soclose panics at this point.
1847          *
1848          * Here, we first take an extra reference to each inaccessible
1849          * descriptor.  Then, we call sorflush ourself, since we know
1850          * it is a Unix domain socket anyhow.  After we destroy all the
1851          * rights carried in messages, we do a last fdrop to get rid
1852          * of our extra reference.  This is the last close, and the
1853          * unp_detach etc will shut down the socket.
1854          *
1855          * 91/09/19, bsy@cs.cmu.edu
1856          */
1857         info.extra_ref = kmalloc(256 * sizeof(struct file *), M_FILE, M_WAITOK);
1858         info.maxindex = 256;
1859
1860         do {
1861                 /*
1862                  * Look for matches
1863                  */
1864                 info.index = 0;
1865                 allfiles_scan_exclusive(unp_gc_checkrefs, &info);
1866
1867                 /*
1868                  * For each FD on our hit list, do the following two things
1869                  */
1870                 for (i = info.index, fpp = info.extra_ref; --i >= 0; ++fpp) {
1871                         struct file *tfp = *fpp;
1872                         if (tfp->f_type == DTYPE_SOCKET && tfp->f_data != NULL)
1873                                 sorflush((struct socket *)(tfp->f_data));
1874                 }
1875                 for (i = info.index, fpp = info.extra_ref; --i >= 0; ++fpp)
1876                         fdrop(*fpp);
1877         } while (info.index == info.maxindex);
1878
1879         kfree((caddr_t)info.extra_ref, M_FILE);
1880
1881         lwkt_reltoken(&unp_rights_token);
1882 }
1883
1884 /*
1885  * MPSAFE - NOTE: filehead list and file pointer spinlocked on entry
1886  */
1887 static int
1888 unp_gc_checkrefs(struct file *fp, void *data)
1889 {
1890         struct unp_gc_info *info = data;
1891
1892         if (fp->f_count == 0)
1893                 return(0);
1894         if (info->index == info->maxindex)
1895                 return(-1);
1896
1897         /*
1898          * If all refs are from msgs, and it's not marked accessible
1899          * then it must be referenced from some unreachable cycle
1900          * of (shut-down) FDs, so include it in our
1901          * list of FDs to remove
1902          */
1903         if (fp->f_count == fp->f_msgcount && !(fp->f_flag & FMARK)) {
1904                 info->extra_ref[info->index++] = fp;
1905                 fhold(fp);
1906         }
1907         return(0);
1908 }
1909
1910 /*
1911  * MPSAFE - NOTE: filehead list and file pointer spinlocked on entry
1912  */
1913 static int
1914 unp_gc_clearmarks(struct file *fp, void *data __unused)
1915 {
1916         atomic_clear_int(&fp->f_flag, FMARK | FDEFER);
1917         return(0);
1918 }
1919
1920 /*
1921  * MPSAFE - NOTE: filehead list and file pointer spinlocked on entry
1922  */
1923 static int
1924 unp_gc_checkmarks(struct file *fp, void *data)
1925 {
1926         struct unp_gc_info *info = data;
1927         struct socket *so;
1928
1929         /*
1930          * If the file is not open, skip it.  Make sure it isn't marked
1931          * defered or we could loop forever, in case we somehow race
1932          * something.
1933          */
1934         if (fp->f_count == 0) {
1935                 if (fp->f_flag & FDEFER)
1936                         atomic_clear_int(&fp->f_flag, FDEFER);
1937                 return(0);
1938         }
1939         /*
1940          * If we already marked it as 'defer'  in a
1941          * previous pass, then try process it this time
1942          * and un-mark it
1943          */
1944         if (fp->f_flag & FDEFER) {
1945                 atomic_clear_int(&fp->f_flag, FDEFER);
1946         } else {
1947                 /*
1948                  * if it's not defered, then check if it's
1949                  * already marked.. if so skip it
1950                  */
1951                 if (fp->f_flag & FMARK)
1952                         return(0);
1953                 /*
1954                  * If all references are from messages
1955                  * in transit, then skip it. it's not
1956                  * externally accessible.
1957                  */
1958                 if (fp->f_count == fp->f_msgcount)
1959                         return(0);
1960                 /*
1961                  * If it got this far then it must be
1962                  * externally accessible.
1963                  */
1964                 atomic_set_int(&fp->f_flag, FMARK);
1965         }
1966
1967         /*
1968          * either it was defered, or it is externally
1969          * accessible and not already marked so.
1970          * Now check if it is possibly one of OUR sockets.
1971          */
1972         if (fp->f_type != DTYPE_SOCKET ||
1973             (so = (struct socket *)fp->f_data) == NULL) {
1974                 return(0);
1975         }
1976         if (so->so_proto->pr_domain != &localdomain ||
1977             !(so->so_proto->pr_flags & PR_RIGHTS)) {
1978                 return(0);
1979         }
1980
1981         /*
1982          * So, Ok, it's one of our sockets and it IS externally accessible
1983          * (or was defered).  Now we look to see if we hold any file
1984          * descriptors in its message buffers.  Follow those links and mark
1985          * them as accessible too.
1986          *
1987          * We are holding multiple spinlocks here, if we cannot get the
1988          * token non-blocking defer until the next loop.
1989          */
1990         info->locked_fp = fp;
1991         if (lwkt_trytoken(&so->so_rcv.ssb_token)) {
1992                 unp_scan(so->so_rcv.ssb_mb, unp_mark, info);
1993                 lwkt_reltoken(&so->so_rcv.ssb_token);
1994         } else {
1995                 atomic_set_int(&fp->f_flag, FDEFER);
1996                 ++info->defer;
1997         }
1998         return (0);
1999 }
2000
2001 /*
2002  * Mark visibility.  info->defer is recalculated on every pass.
2003  */
2004 static void
2005 unp_mark(struct file *fp, void *data)
2006 {
2007         struct unp_gc_info *info = data;
2008
2009         if ((fp->f_flag & FMARK) == 0) {
2010                 ++info->defer;
2011                 atomic_set_int(&fp->f_flag, FMARK | FDEFER);
2012         } else if (fp->f_flag & FDEFER) {
2013                 ++info->defer;
2014         }
2015 }
2016
2017 #else   /* !UNP_GC_ALLFILES */
2018
2019 /*
2020  * They are thread local and do not require explicit synchronization.
2021  */
2022 static int      unp_marked;
2023 static int      unp_unreachable;
2024
2025 static void
2026 unp_accessable(struct file *fp, void *data __unused)
2027 {
2028         struct unpcb *unp;
2029
2030         if ((unp = unp_fp2unpcb(fp)) == NULL)
2031                 return;
2032         if (unp->unp_gcflags & UNPGC_REF)
2033                 return;
2034         unp->unp_gcflags &= ~UNPGC_DEAD;
2035         unp->unp_gcflags |= UNPGC_REF;
2036         unp_marked++;
2037 }
2038
2039 static void
2040 unp_gc_process(struct unpcb *unp)
2041 {
2042         struct file *fp;
2043
2044         /* Already processed. */
2045         if (unp->unp_gcflags & UNPGC_SCANNED)
2046                 return;
2047         fp = unp->unp_fp;
2048
2049         /*
2050          * Check for a socket potentially in a cycle.  It must be in a
2051          * queue as indicated by msgcount, and this must equal the file
2052          * reference count.  Note that when msgcount is 0 the file is NULL.
2053          */
2054         if ((unp->unp_gcflags & UNPGC_REF) == 0 && fp &&
2055             unp->unp_msgcount != 0 && fp->f_count == unp->unp_msgcount) {
2056                 unp->unp_gcflags |= UNPGC_DEAD;
2057                 unp_unreachable++;
2058                 return;
2059         }
2060
2061         /*
2062          * Mark all sockets we reference with RIGHTS.
2063          */
2064         if (UNP_ISATTACHED(unp)) {
2065                 struct signalsockbuf *ssb = &unp->unp_socket->so_rcv;
2066
2067                 unp_reference(unp);
2068                 lwkt_gettoken(&ssb->ssb_token);
2069                 /*
2070                  * unp_token would be temporarily dropped, if getting
2071                  * so_rcv token blocks, so we need to check unp state
2072                  * here again.
2073                  */
2074                 if (UNP_ISATTACHED(unp))
2075                         unp_scan(ssb->ssb_mb, unp_accessable, NULL);
2076                 lwkt_reltoken(&ssb->ssb_token);
2077                 unp->unp_gcflags |= UNPGC_SCANNED;
2078                 unp_free(unp);
2079         } else {
2080                 unp->unp_gcflags |= UNPGC_SCANNED;
2081         }
2082 }
2083
2084 static void
2085 unp_gc(void *arg __unused, int pending __unused)
2086 {
2087         struct unp_global_head *head;
2088         int h, filemax, fileidx, filetot;
2089         struct file **unref;
2090         struct unpcb *unp;
2091
2092         lwkt_gettoken(&unp_rights_token);
2093         lwkt_gettoken(&unp_token);
2094
2095         /*
2096          * First clear all gc flags from previous runs.
2097          */
2098         for (h = 0; unp_heads[h] != NULL; ++h) {
2099                 /*
2100                  * NOTE: This loop does not block, so it is safe
2101                  * to use TAILQ_FOREACH here.
2102                  */
2103                 head = unp_heads[h];
2104                 TAILQ_FOREACH(unp, &head->list, unp_link)
2105                         unp->unp_gcflags = 0;
2106         }
2107
2108         /*
2109          * Scan marking all reachable sockets with UNPGC_REF.  Once a socket
2110          * is reachable all of the sockets it references are reachable.
2111          * Stop the scan once we do a complete loop without discovering
2112          * a new reachable socket.
2113          */
2114         do {
2115                 unp_unreachable = 0;
2116                 unp_marked = 0;
2117                 for (h = 0; unp_heads[h] != NULL; ++h) {
2118                         head = unp_heads[h];
2119                         TAILQ_INSERT_HEAD(&head->list, unp_gc_marker, unp_link);
2120                         while ((unp = TAILQ_NEXT(unp_gc_marker, unp_link))
2121                             != NULL) {
2122                                 TAILQ_REMOVE(&head->list, unp_gc_marker,
2123                                     unp_link);
2124                                 TAILQ_INSERT_AFTER(&head->list, unp,
2125                                     unp_gc_marker, unp_link);
2126
2127                                 if (unp->unp_flags & UNP_MARKER)
2128                                         continue;
2129                                 unp_gc_process(unp);
2130                         }
2131                         TAILQ_REMOVE(&head->list, unp_gc_marker, unp_link);
2132                 }
2133         } while (unp_marked);
2134
2135         if (unp_unreachable == 0)
2136                 goto done;
2137
2138         /*
2139          * We grab an extra reference to each of the file table entries
2140          * that are not otherwise accessible and then free the rights
2141          * that are stored in messages on them.
2142          *
2143          * The bug in the orginal code is a little tricky, so I'll describe
2144          * what's wrong with it here.
2145          *
2146          * It is incorrect to simply unp_discard each entry for f_msgcount
2147          * times -- consider the case of sockets A and B that contain
2148          * references to each other.  On a last close of some other socket,
2149          * we trigger a gc since the number of outstanding rights (unp_rights)
2150          * is non-zero.  If during the sweep phase the gc code unp_discards,
2151          * we end up doing a (full) fdrop on the descriptor.  A fdrop on A
2152          * results in the following chain.  Closef calls soo_close, which
2153          * calls soclose.   Soclose calls first (through the switch
2154          * uipc_usrreq) unp_detach, which re-invokes unp_gc.  Unp_gc simply
2155          * returns because the previous instance had set unp_gcing, and
2156          * we return all the way back to soclose, which marks the socket
2157          * with SS_NOFDREF, and then calls sofree.  Sofree calls sorflush
2158          * to free up the rights that are queued in messages on the socket A,
2159          * i.e., the reference on B.  The sorflush calls via the dom_dispose
2160          * switch unp_dispose, which unp_scans with unp_discard.  This second
2161          * instance of unp_discard just calls fdrop on B.
2162          *
2163          * Well, a similar chain occurs on B, resulting in a sorflush on B,
2164          * which results in another fdrop on A.  Unfortunately, A is already
2165          * being closed, and the descriptor has already been marked with
2166          * SS_NOFDREF, and soclose panics at this point.
2167          *
2168          * Here, we first take an extra reference to each inaccessible
2169          * descriptor.  Then, we call sorflush ourself, since we know
2170          * it is a Unix domain socket anyhow.  After we destroy all the
2171          * rights carried in messages, we do a last fdrop to get rid
2172          * of our extra reference.  This is the last close, and the
2173          * unp_detach etc will shut down the socket.
2174          *
2175          * 91/09/19, bsy@cs.cmu.edu
2176          */
2177
2178         filemax = unp_unreachable;
2179         if (filemax > UNP_GCFILE_MAX)
2180                 filemax = UNP_GCFILE_MAX;
2181         unref = kmalloc(filemax * sizeof(struct file *), M_TEMP, M_WAITOK);
2182
2183         filetot = 0;
2184         do {
2185                 int i;
2186
2187                 /*
2188                  * Iterate looking for sockets which have been specifically
2189                  * marked as as unreachable and store them locally.
2190                  */
2191                 fileidx = 0;
2192                 for (h = 0; unp_heads[h] != NULL; ++h) {
2193                         /*
2194                          * NOTE: This loop does not block, so it is safe
2195                          * to use TAILQ_FOREACH here.
2196                          */
2197                         head = unp_heads[h];
2198                         TAILQ_FOREACH(unp, &head->list, unp_link) {
2199                                 struct file *fp;
2200
2201                                 if ((unp->unp_gcflags & UNPGC_DEAD) == 0)
2202                                         continue;
2203                                 unp->unp_gcflags &= ~UNPGC_DEAD;
2204
2205                                 fp = unp->unp_fp;
2206                                 if (unp->unp_msgcount == 0 || fp == NULL ||
2207                                     fp->f_count != unp->unp_msgcount)
2208                                         continue;
2209                                 fhold(fp);
2210
2211                                 KASSERT(fileidx < filemax,
2212                                     ("invalid fileidx %d, filemax %d",
2213                                      fileidx, filemax));
2214                                 unref[fileidx++] = fp;
2215
2216                                 KASSERT(filetot < unp_unreachable,
2217                                     ("invalid filetot %d and "
2218                                      "unp_unreachable %d",
2219                                      filetot, unp_unreachable));
2220                                 ++filetot;
2221
2222                                 if (fileidx == filemax ||
2223                                     filetot == unp_unreachable)
2224                                         goto dogc;
2225                         }
2226                 }
2227 dogc:
2228                 /*
2229                  * For each Unix domain socket on our hit list, do the
2230                  * following two things.
2231                  */
2232                 for (i = 0; i < fileidx; ++i)
2233                         sorflush(unref[i]->f_data);
2234                 for (i = 0; i < fileidx; ++i)
2235                         fdrop(unref[i]);
2236         } while (fileidx == filemax && filetot < unp_unreachable);
2237         kfree(unref, M_TEMP);
2238 done:
2239         lwkt_reltoken(&unp_token);
2240         lwkt_reltoken(&unp_rights_token);
2241 }
2242
2243 #endif  /* UNP_GC_ALLFILES */
2244
2245 /*
2246  * Dispose of the fp's stored in a mbuf.
2247  *
2248  * The dds loop can cause additional fps to be entered onto the
2249  * list while it is running, flattening out the operation and avoiding
2250  * a deep kernel stack recursion.
2251  */
2252 void
2253 unp_dispose(struct mbuf *m)
2254 {
2255         lwkt_gettoken(&unp_rights_token);
2256         if (m)
2257                 unp_scan(m, unp_discard, NULL);
2258         lwkt_reltoken(&unp_rights_token);
2259 }
2260
2261 static int
2262 unp_listen(struct unpcb *unp, struct thread *td)
2263 {
2264         struct proc *p = td->td_proc;
2265
2266         ASSERT_LWKT_TOKEN_HELD(&unp_token);
2267         UNP_ASSERT_TOKEN_HELD(unp);
2268
2269         KKASSERT(p);
2270         cru2x(p->p_ucred, &unp->unp_peercred);
2271         unp_setflags(unp, UNP_HAVEPCCACHED);
2272         return (0);
2273 }
2274
2275 static void
2276 unp_scan(struct mbuf *m0, void (*op)(struct file *, void *), void *data)
2277 {
2278         struct mbuf *m;
2279         struct file **rp;
2280         struct cmsghdr *cm;
2281         int i;
2282         int qfds;
2283
2284         while (m0) {
2285                 for (m = m0; m; m = m->m_next) {
2286                         if (m->m_type == MT_CONTROL &&
2287                             m->m_len >= sizeof(*cm)) {
2288                                 cm = mtod(m, struct cmsghdr *);
2289                                 if (cm->cmsg_level != SOL_SOCKET ||
2290                                     cm->cmsg_type != SCM_RIGHTS)
2291                                         continue;
2292                                 qfds = (cm->cmsg_len - CMSG_LEN(0)) /
2293                                         sizeof(void *);
2294                                 rp = (struct file **)CMSG_DATA(cm);
2295                                 for (i = 0; i < qfds; i++)
2296                                         (*op)(*rp++, data);
2297                                 break;          /* XXX, but saves time */
2298                         }
2299                 }
2300                 m0 = m0->m_nextpkt;
2301         }
2302 }
2303
2304 /*
2305  * Discard a fp previously held in a unix domain socket mbuf.  To
2306  * avoid blowing out the kernel stack due to contrived chain-reactions
2307  * we may have to defer the operation to a dedicated taskqueue.
2308  *
2309  * Caller holds unp_rights_token.
2310  */
2311 static void
2312 unp_discard(struct file *fp, void *data __unused)
2313 {
2314         unp_del_right(fp);
2315         if (unp_fp2unpcb(fp) != NULL) {
2316                 struct unp_defdiscard *d;
2317
2318                 /*
2319                  * This fp is a Unix domain socket itself and fdrop()
2320                  * it here directly may cause deep unp_discard()
2321                  * recursion, so the fdrop() is defered to the
2322                  * dedicated taskqueue.
2323                  */
2324                 d = kmalloc(sizeof(*d), M_UNPCB, M_WAITOK);
2325                 d->fp = fp;
2326
2327                 spin_lock(&unp_defdiscard_spin);
2328                 SLIST_INSERT_HEAD(&unp_defdiscard_head, d, next);
2329                 spin_unlock(&unp_defdiscard_spin);
2330
2331                 taskqueue_enqueue(unp_taskqueue, &unp_defdiscard_task);
2332         } else {
2333                 /* This fp is not a Unix domain socket */
2334                 fdrop(fp);
2335         }
2336 }
2337
2338 /*
2339  * NOTE:
2340  * unp_token must be held before calling this function to avoid name
2341  * resolution and v_socket accessing races, especially racing against
2342  * the unp_detach().
2343  *
2344  * NOTE:
2345  * For anyone caring about unconnected Unix domain socket sending
2346  * performance, other approach could be taken...
2347  */
2348 static int
2349 unp_find_lockref(struct sockaddr *nam, struct thread *td, short type,
2350     struct unpcb **unp_ret)
2351 {
2352         struct proc *p = td->td_proc;
2353         struct sockaddr_un *soun = (struct sockaddr_un *)nam;
2354         struct vnode *vp = NULL;
2355         struct socket *so;
2356         struct unpcb *unp;
2357         int error, len;
2358         struct nlookupdata nd;
2359         char buf[SOCK_MAXADDRLEN];
2360
2361         ASSERT_LWKT_TOKEN_HELD(&unp_token);
2362
2363         *unp_ret = NULL;
2364
2365         len = nam->sa_len - offsetof(struct sockaddr_un, sun_path);
2366         if (len <= 0) {
2367                 error = EINVAL;
2368                 goto failed;
2369         }
2370         strncpy(buf, soun->sun_path, len);
2371         buf[len] = 0;
2372
2373         error = nlookup_init(&nd, buf, UIO_SYSSPACE, NLC_FOLLOW);
2374         if (error == 0)
2375                 error = nlookup(&nd);
2376         if (error == 0)
2377                 error = cache_vget(&nd.nl_nch, nd.nl_cred, LK_EXCLUSIVE, &vp);
2378         nlookup_done(&nd);
2379         if (error) {
2380                 vp = NULL;
2381                 goto failed;
2382         }
2383
2384         if (vp->v_type != VSOCK) {
2385                 error = ENOTSOCK;
2386                 goto failed;
2387         }
2388         error = VOP_EACCESS(vp, VWRITE, p->p_ucred);
2389         if (error)
2390                 goto failed;
2391         so = vp->v_socket;
2392         if (so == NULL) {
2393                 error = ECONNREFUSED;
2394                 goto failed;
2395         }
2396         if (so->so_type != type) {
2397                 error = EPROTOTYPE;
2398                 goto failed;
2399         }
2400
2401         /* Lock this unp. */
2402         unp = unp_getsocktoken(so);
2403         if (!UNP_ISATTACHED(unp)) {
2404                 unp_reltoken(unp);
2405                 error = ECONNREFUSED;
2406                 goto failed;
2407         }
2408         /* And keep this unp referenced. */
2409         unp_reference(unp);
2410
2411         /* Done! */
2412         *unp_ret = unp;
2413         error = 0;
2414 failed:
2415         if (vp != NULL)
2416                 vput(vp);
2417         return error;
2418 }
2419
2420 static int
2421 unp_connect_pair(struct unpcb *unp, struct unpcb *unp2)
2422 {
2423         struct socket *so = unp->unp_socket;
2424         struct socket *so2 = unp2->unp_socket;
2425
2426         ASSERT_LWKT_TOKEN_HELD(&unp_token);
2427         UNP_ASSERT_TOKEN_HELD(unp);
2428         UNP_ASSERT_TOKEN_HELD(unp2);
2429
2430         KASSERT(so->so_type == so2->so_type,
2431             ("socket type mismatch, so %d, so2 %d", so->so_type, so2->so_type));
2432
2433         if (!UNP_ISATTACHED(unp))
2434                 return EINVAL;
2435         if (!UNP_ISATTACHED(unp2))
2436                 return ECONNREFUSED;
2437
2438         KASSERT(unp->unp_conn == NULL, ("unp is already connected"));
2439         unp->unp_conn = unp2;
2440
2441         switch (so->so_type) {
2442         case SOCK_DGRAM:
2443                 LIST_INSERT_HEAD(&unp2->unp_refs, unp, unp_reflink);
2444                 soisconnected(so);
2445                 break;
2446
2447         case SOCK_STREAM:
2448         case SOCK_SEQPACKET:
2449                 KASSERT(unp2->unp_conn == NULL, ("unp2 is already connected"));
2450                 unp2->unp_conn = unp;
2451                 soisconnected(so);
2452                 soisconnected(so2);
2453                 break;
2454
2455         default:
2456                 panic("unp_connect_pair: unknown socket type %d", so->so_type);
2457         }
2458         return 0;
2459 }
2460
2461 static void
2462 unp_drop(struct unpcb *unp, int error)
2463 {
2464         struct unp_global_head *head;
2465         struct unpcb *unp2;
2466
2467         ASSERT_LWKT_TOKEN_HELD(&unp_token);
2468         UNP_ASSERT_TOKEN_HELD(unp);
2469
2470         KASSERT((unp->unp_flags & (UNP_DETACHED | UNP_DROPPED)) == 0,
2471             ("unp is dropped"));
2472
2473         /* Mark this unp as detached. */
2474         unp_setflags(unp, UNP_DETACHED);
2475
2476         /* Remove this unp from the global unp list. */
2477         head = unp_globalhead(unp->unp_socket->so_type);
2478         KASSERT(head->count > 0, ("invalid unp count"));
2479         TAILQ_REMOVE(&head->list, unp, unp_link);
2480         head->count--;
2481
2482         /* Disconnect all. */
2483         unp_disconnect(unp, error);
2484         while ((unp2 = LIST_FIRST(&unp->unp_refs)) != NULL) {
2485                 lwkt_getpooltoken(unp2);
2486                 unp_disconnect(unp2, ECONNRESET);
2487                 lwkt_relpooltoken(unp2);
2488         }
2489         unp_setflags(unp, UNP_DROPPED);
2490
2491         /* Try freeing this unp. */
2492         unp_free(unp);
2493 }
2494
2495 static void
2496 unp_defdiscard_taskfunc(void *arg __unused, int pending __unused)
2497 {
2498         struct unp_defdiscard *d;
2499
2500         spin_lock(&unp_defdiscard_spin);
2501         while ((d = SLIST_FIRST(&unp_defdiscard_head)) != NULL) {
2502                 SLIST_REMOVE_HEAD(&unp_defdiscard_head, next);
2503                 spin_unlock(&unp_defdiscard_spin);
2504
2505                 fdrop(d->fp);
2506                 kfree(d, M_UNPCB);
2507
2508                 spin_lock(&unp_defdiscard_spin);
2509         }
2510         spin_unlock(&unp_defdiscard_spin);
2511 }