1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 
  22 /*
  23  * Copyright (c) 1989, 2010, Oracle and/or its affiliates. All rights reserved.
  24  * Copyright (c) 2012, Joyent Inc. All rights reserved.
  25  */
  26 
  27 /*      Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T     */
  28 /*      All Rights Reserved */
  29 
  30 #include <sys/types.h>
  31 #include <sys/sysmacros.h>
  32 #include <sys/param.h>
  33 #include <sys/systm.h>
  34 #include <sys/errno.h>
  35 #include <sys/signal.h>
  36 #include <sys/cred.h>
  37 #include <sys/user.h>
  38 #include <sys/conf.h>
  39 #include <sys/vfs.h>
  40 #include <sys/vnode.h>
  41 #include <sys/pathname.h>
  42 #include <sys/file.h>
  43 #include <sys/proc.h>
  44 #include <sys/var.h>
  45 #include <sys/cpuvar.h>
  46 #include <sys/open.h>
  47 #include <sys/cmn_err.h>
  48 #include <sys/priocntl.h>
  49 #include <sys/procset.h>
  50 #include <sys/prsystm.h>
  51 #include <sys/debug.h>
  52 #include <sys/kmem.h>
  53 #include <sys/atomic.h>
  54 #include <sys/fcntl.h>
  55 #include <sys/poll.h>
  56 #include <sys/rctl.h>
  57 #include <sys/port_impl.h>
  58 #include <sys/dtrace.h>
  59 
  60 #include <c2/audit.h>
  61 #include <sys/nbmlock.h>
  62 
  63 #ifdef DEBUG
  64 
  65 static uint32_t afd_maxfd;      /* # of entries in maximum allocated array */
  66 static uint32_t afd_alloc;      /* count of kmem_alloc()s */
  67 static uint32_t afd_free;       /* count of kmem_free()s */
  68 static uint32_t afd_wait;       /* count of waits on non-zero ref count */
  69 #define MAXFD(x)        (afd_maxfd = ((afd_maxfd >= (x))? afd_maxfd : (x)))
  70 #define COUNT(x)        atomic_inc_32(&x)
  71 
  72 #else   /* DEBUG */
  73 
  74 #define MAXFD(x)
  75 #define COUNT(x)
  76 
  77 #endif  /* DEBUG */
  78 
  79 kmem_cache_t *file_cache;
  80 
  81 static void port_close_fd(portfd_t *);
  82 
  83 /*
  84  * File descriptor allocation.
  85  *
  86  * fd_find(fip, minfd) finds the first available descriptor >= minfd.
  87  * The most common case is open(2), in which minfd = 0, but we must also
  88  * support fcntl(fd, F_DUPFD, minfd).
  89  *
  90  * The algorithm is as follows: we keep all file descriptors in an infix
  91  * binary tree in which each node records the number of descriptors
  92  * allocated in its right subtree, including itself.  Starting at minfd,
  93  * we ascend the tree until we find a non-fully allocated right subtree.
  94  * We then descend that subtree in a binary search for the smallest fd.
  95  * Finally, we ascend the tree again to increment the allocation count
  96  * of every subtree containing the newly-allocated fd.  Freeing an fd
  97  * requires only the last step: we ascend the tree to decrement allocation
  98  * counts.  Each of these three steps (ascent to find non-full subtree,
  99  * descent to find lowest fd, ascent to update allocation counts) is
 100  * O(log n), thus the algorithm as a whole is O(log n).
 101  *
 102  * We don't implement the fd tree using the customary left/right/parent
 103  * pointers, but instead take advantage of the glorious mathematics of
 104  * full infix binary trees.  For reference, here's an illustration of the
 105  * logical structure of such a tree, rooted at 4 (binary 100), covering
 106  * the range 1-7 (binary 001-111).  Our canonical trees do not include
 107  * fd 0; we'll deal with that later.
 108  *
 109  *            100
 110  *           /   \
 111  *          /     \
 112  *        010     110
 113  *        / \     / \
 114  *      001 011 101 111
 115  *
 116  * We make the following observations, all of which are easily proven by
 117  * induction on the depth of the tree:
 118  *
 119  * (T1) The least-significant bit (LSB) of any node is equal to its level
 120  *      in the tree.  In our example, nodes 001, 011, 101 and 111 are at
 121  *      level 0; nodes 010 and 110 are at level 1; and node 100 is at level 2.
 122  *
 123  * (T2) The child size (CSIZE) of node N -- that is, the total number of
 124  *      right-branch descendants in a child of node N, including itself -- is
 125  *      given by clearing all but the least significant bit of N.  This
 126  *      follows immediately from (T1).  Applying this rule to our example, we
 127  *      see that CSIZE(100) = 100, CSIZE(x10) = 10, and CSIZE(xx1) = 1.
 128  *
 129  * (T3) The nearest left ancestor (LPARENT) of node N -- that is, the nearest
 130  *      ancestor containing node N in its right child -- is given by clearing
 131  *      the LSB of N.  For example, LPARENT(111) = 110 and LPARENT(110) = 100.
 132  *      Clearing the LSB of nodes 001, 010 or 100 yields zero, reflecting
 133  *      the fact that these are leftmost nodes.  Note that this algorithm
 134  *      automatically skips generations as necessary.  For example, the parent
 135  *      of node 101 is 110, which is a *right* ancestor (not what we want);
 136  *      but its grandparent is 100, which is a left ancestor. Clearing the LSB
 137  *      of 101 gets us to 100 directly, skipping right past the uninteresting
 138  *      generation (110).
 139  *
 140  *      Note that since LPARENT clears the LSB, whereas CSIZE clears all *but*
 141  *      the LSB, we can express LPARENT() nicely in terms of CSIZE():
 142  *
 143  *      LPARENT(N) = N - CSIZE(N)
 144  *
 145  * (T4) The nearest right ancestor (RPARENT) of node N is given by:
 146  *
 147  *      RPARENT(N) = N + CSIZE(N)
 148  *
 149  * (T5) For every interior node, the children differ from their parent by
 150  *      CSIZE(parent) / 2.  In our example, CSIZE(100) / 2 = 2 = 10 binary,
 151  *      and indeed, the children of 100 are 100 +/- 10 = 010 and 110.
 152  *
 153  * Next, we'll need a few two's-complement math tricks.  Suppose a number,
 154  * N, has the following form:
 155  *
 156  *              N = xxxx10...0
 157  *
 158  * That is, the binary representation of N consists of some string of bits,
 159  * then a 1, then all zeroes.  This amounts to nothing more than saying that
 160  * N has a least-significant bit, which is true for any N != 0.  If we look
 161  * at N and N - 1 together, we see that we can combine them in useful ways:
 162  *
 163  *                N = xxxx10...0
 164  *            N - 1 = xxxx01...1
 165  *      ------------------------
 166  *      N & (N - 1) = xxxx000000
 167  *      N | (N - 1) = xxxx111111
 168  *      N ^ (N - 1) =     111111
 169  *
 170  * In particular, this suggests several easy ways to clear all but the LSB,
 171  * which by (T2) is exactly what we need to determine CSIZE(N) = 10...0.
 172  * We'll opt for this formulation:
 173  *
 174  *      (C1) CSIZE(N) = (N - 1) ^ (N | (N - 1))
 175  *
 176  * Similarly, we have an easy way to determine LPARENT(N), which requires
 177  * that we clear the LSB of N:
 178  *
 179  *      (L1) LPARENT(N) = N & (N - 1)
 180  *
 181  * We note in the above relations that (N | (N - 1)) - N = CSIZE(N) - 1.
 182  * When combined with (T4), this yields an easy way to compute RPARENT(N):
 183  *
 184  *      (R1) RPARENT(N) = (N | (N - 1)) + 1
 185  *
 186  * Finally, to accommodate fd 0 we must adjust all of our results by +/-1 to
 187  * move the fd range from [1, 2^n) to [0, 2^n - 1).  This is straightforward,
 188  * so there's no need to belabor the algebra; the revised relations become:
 189  *
 190  *      (C1a) CSIZE(N) = N ^ (N | (N + 1))
 191  *
 192  *      (L1a) LPARENT(N) = (N & (N + 1)) - 1
 193  *
 194  *      (R1a) RPARENT(N) = N | (N + 1)
 195  *
 196  * This completes the mathematical framework.  We now have all the tools
 197  * we need to implement fd_find() and fd_reserve().
 198  *
 199  * fd_find(fip, minfd) finds the smallest available file descriptor >= minfd.
 200  * It does not actually allocate the descriptor; that's done by fd_reserve().
 201  * fd_find() proceeds in two steps:
 202  *
 203  * (1) Find the leftmost subtree that contains a descriptor >= minfd.
 204  *     We start at the right subtree rooted at minfd.  If this subtree is
 205  *     not full -- if fip->fi_list[minfd].uf_alloc != CSIZE(minfd) -- then
 206  *     step 1 is done.  Otherwise, we know that all fds in this subtree
 207  *     are taken, so we ascend to RPARENT(minfd) using (R1a).  We repeat
 208  *     this process until we either find a candidate subtree or exceed
 209  *     fip->fi_nfiles.  We use (C1a) to compute CSIZE().
 210  *
 211  * (2) Find the smallest fd in the subtree discovered by step 1.
 212  *     Starting at the root of this subtree, we descend to find the
 213  *     smallest available fd.  Since the left children have the smaller
 214  *     fds, we will descend rightward only when the left child is full.
 215  *
 216  *     We begin by comparing the number of allocated fds in the root
 217  *     to the number of allocated fds in its right child; if they differ
 218  *     by exactly CSIZE(child), we know the left subtree is full, so we
 219  *     descend right; that is, the right child becomes the search root.
 220  *     Otherwise we leave the root alone and start following the right
 221  *     child's left children.  As fortune would have it, this is very
 222  *     simple computationally: by (T5), the right child of fd is just
 223  *     fd + size, where size = CSIZE(fd) / 2.  Applying (T5) again,
 224  *     we find that the right child's left child is fd + size - (size / 2) =
 225  *     fd + (size / 2); *its* left child is fd + (size / 2) - (size / 4) =
 226  *     fd + (size / 4), and so on.  In general, fd's right child's
 227  *     leftmost nth descendant is fd + (size >> n).  Thus, to follow
 228  *     the right child's left descendants, we just halve the size in
 229  *     each iteration of the search.
 230  *
 231  *     When we descend leftward, we must keep track of the number of fds
 232  *     that were allocated in all the right subtrees we rejected, so we
 233  *     know how many of the root fd's allocations are in the remaining
 234  *     (as yet unexplored) leftmost part of its right subtree.  When we
 235  *     encounter a fully-allocated left child -- that is, when we find
 236  *     that fip->fi_list[fd].uf_alloc == ralloc + size -- we descend right
 237  *     (as described earlier), resetting ralloc to zero.
 238  *
 239  * fd_reserve(fip, fd, incr) either allocates or frees fd, depending
 240  * on whether incr is 1 or -1.  Starting at fd, fd_reserve() ascends
 241  * the leftmost ancestors (see (T3)) and updates the allocation counts.
 242  * At each step we use (L1a) to compute LPARENT(), the next left ancestor.
 243  *
 244  * flist_minsize() finds the minimal tree that still covers all
 245  * used fds; as long as the allocation count of a root node is zero, we
 246  * don't need that node or its right subtree.
 247  *
 248  * flist_nalloc() counts the number of allocated fds in the tree, by starting
 249  * at the top of the tree and summing the right-subtree allocation counts as
 250  * it descends leftwards.
 251  *
 252  * Note: we assume that flist_grow() will keep fip->fi_nfiles of the form
 253  * 2^n - 1.  This ensures that the fd trees are always full, which saves
 254  * quite a bit of boundary checking.
 255  */
 256 static int
 257 fd_find(uf_info_t *fip, int minfd)
 258 {
 259         int size, ralloc, fd;
 260 
 261         ASSERT(MUTEX_HELD(&fip->fi_lock));
 262         ASSERT((fip->fi_nfiles & (fip->fi_nfiles + 1)) == 0);
 263 
 264         for (fd = minfd; (uint_t)fd < fip->fi_nfiles; fd |= fd + 1) {
 265                 size = fd ^ (fd | (fd + 1));
 266                 if (fip->fi_list[fd].uf_alloc == size)
 267                         continue;
 268                 for (ralloc = 0, size >>= 1; size != 0; size >>= 1) {
 269                         ralloc += fip->fi_list[fd + size].uf_alloc;
 270                         if (fip->fi_list[fd].uf_alloc == ralloc + size) {
 271                                 fd += size;
 272                                 ralloc = 0;
 273                         }
 274                 }
 275                 return (fd);
 276         }
 277         return (-1);
 278 }
 279 
 280 static void
 281 fd_reserve(uf_info_t *fip, int fd, int incr)
 282 {
 283         int pfd;
 284         uf_entry_t *ufp = &fip->fi_list[fd];
 285 
 286         ASSERT((uint_t)fd < fip->fi_nfiles);
 287         ASSERT((ufp->uf_busy == 0 && incr == 1) ||
 288             (ufp->uf_busy == 1 && incr == -1));
 289         ASSERT(MUTEX_HELD(&ufp->uf_lock));
 290         ASSERT(MUTEX_HELD(&fip->fi_lock));
 291 
 292         for (pfd = fd; pfd >= 0; pfd = (pfd & (pfd + 1)) - 1)
 293                 fip->fi_list[pfd].uf_alloc += incr;
 294 
 295         ufp->uf_busy += incr;
 296 }
 297 
 298 static int
 299 flist_minsize(uf_info_t *fip)
 300 {
 301         int fd;
 302 
 303         /*
 304          * We'd like to ASSERT(MUTEX_HELD(&fip->fi_lock)), but we're called
 305          * by flist_fork(), which relies on other mechanisms for mutual
 306          * exclusion.
 307          */
 308         ASSERT((fip->fi_nfiles & (fip->fi_nfiles + 1)) == 0);
 309 
 310         for (fd = fip->fi_nfiles; fd != 0; fd >>= 1)
 311                 if (fip->fi_list[fd >> 1].uf_alloc != 0)
 312                         break;
 313 
 314         return (fd);
 315 }
 316 
 317 static int
 318 flist_nalloc(uf_info_t *fip)
 319 {
 320         int fd;
 321         int nalloc = 0;
 322 
 323         ASSERT(MUTEX_HELD(&fip->fi_lock));
 324         ASSERT((fip->fi_nfiles & (fip->fi_nfiles + 1)) == 0);
 325 
 326         for (fd = fip->fi_nfiles; fd != 0; fd >>= 1)
 327                 nalloc += fip->fi_list[fd >> 1].uf_alloc;
 328 
 329         return (nalloc);
 330 }
 331 
 332 /*
 333  * Increase size of the fi_list array to accommodate at least maxfd.
 334  * We keep the size of the form 2^n - 1 for benefit of fd_find().
 335  */
 336 static void
 337 flist_grow(int maxfd)
 338 {
 339         uf_info_t *fip = P_FINFO(curproc);
 340         int newcnt, oldcnt;
 341         uf_entry_t *src, *dst, *newlist, *oldlist, *newend, *oldend;
 342         uf_rlist_t *urp;
 343 
 344         for (newcnt = 1; newcnt <= maxfd; newcnt = (newcnt << 1) | 1)
 345                 continue;
 346 
 347         newlist = kmem_zalloc(newcnt * sizeof (uf_entry_t), KM_SLEEP);
 348 
 349         mutex_enter(&fip->fi_lock);
 350         oldcnt = fip->fi_nfiles;
 351         if (newcnt <= oldcnt) {
 352                 mutex_exit(&fip->fi_lock);
 353                 kmem_free(newlist, newcnt * sizeof (uf_entry_t));
 354                 return;
 355         }
 356         ASSERT((newcnt & (newcnt + 1)) == 0);
 357         oldlist = fip->fi_list;
 358         oldend = oldlist + oldcnt;
 359         newend = newlist + oldcnt;      /* no need to lock beyond old end */
 360 
 361         /*
 362          * fi_list and fi_nfiles cannot change while any uf_lock is held,
 363          * so we must grab all the old locks *and* the new locks up to oldcnt.
 364          * (Locks beyond the end of oldcnt aren't visible until we store
 365          * the new fi_nfiles, which is the last thing we do before dropping
 366          * all the locks, so there's no need to acquire these locks).
 367          * Holding the new locks is necessary because when fi_list changes
 368          * to point to the new list, fi_nfiles won't have been stored yet.
 369          * If we *didn't* hold the new locks, someone doing a UF_ENTER()
 370          * could see the new fi_list, grab the new uf_lock, and then see
 371          * fi_nfiles change while the lock is held -- in violation of
 372          * UF_ENTER() semantics.
 373          */
 374         for (src = oldlist; src < oldend; src++)
 375                 mutex_enter(&src->uf_lock);
 376 
 377         for (dst = newlist; dst < newend; dst++)
 378                 mutex_enter(&dst->uf_lock);
 379 
 380         for (src = oldlist, dst = newlist; src < oldend; src++, dst++) {
 381                 dst->uf_file = src->uf_file;
 382                 dst->uf_fpollinfo = src->uf_fpollinfo;
 383                 dst->uf_refcnt = src->uf_refcnt;
 384                 dst->uf_alloc = src->uf_alloc;
 385                 dst->uf_flag = src->uf_flag;
 386                 dst->uf_busy = src->uf_busy;
 387                 dst->uf_portfd = src->uf_portfd;
 388         }
 389 
 390         /*
 391          * As soon as we store the new flist, future locking operations
 392          * will use it.  Therefore, we must ensure that all the state
 393          * we've just established reaches global visibility before the
 394          * new flist does.
 395          */
 396         membar_producer();
 397         fip->fi_list = newlist;
 398 
 399         /*
 400          * Routines like getf() make an optimistic check on the validity
 401          * of the supplied file descriptor: if it's less than the current
 402          * value of fi_nfiles -- examined without any locks -- then it's
 403          * safe to attempt a UF_ENTER() on that fd (which is a valid
 404          * assumption because fi_nfiles only increases).  Therefore, it
 405          * is critical that the new value of fi_nfiles not reach global
 406          * visibility until after the new fi_list: if it happened the
 407          * other way around, getf() could see the new fi_nfiles and attempt
 408          * a UF_ENTER() on the old fi_list, which would write beyond its
 409          * end if the fd exceeded the old fi_nfiles.
 410          */
 411         membar_producer();
 412         fip->fi_nfiles = newcnt;
 413 
 414         /*
 415          * The new state is consistent now, so we can drop all the locks.
 416          */
 417         for (dst = newlist; dst < newend; dst++)
 418                 mutex_exit(&dst->uf_lock);
 419 
 420         for (src = oldlist; src < oldend; src++) {
 421                 /*
 422                  * If any threads are blocked on the old cvs, wake them.
 423                  * This will force them to wake up, discover that fi_list
 424                  * has changed, and go back to sleep on the new cvs.
 425                  */
 426                 cv_broadcast(&src->uf_wanted_cv);
 427                 cv_broadcast(&src->uf_closing_cv);
 428                 mutex_exit(&src->uf_lock);
 429         }
 430 
 431         mutex_exit(&fip->fi_lock);
 432 
 433         /*
 434          * Retire the old flist.  We can't actually kmem_free() it now
 435          * because someone may still have a pointer to it.  Instead,
 436          * we link it onto a list of retired flists.  The new flist
 437          * is at least double the size of the previous flist, so the
 438          * total size of all retired flists will be less than the size
 439          * of the current one (to prove, consider the sum of a geometric
 440          * series in powers of 2).  exit() frees the retired flists.
 441          */
 442         urp = kmem_zalloc(sizeof (uf_rlist_t), KM_SLEEP);
 443         urp->ur_list = oldlist;
 444         urp->ur_nfiles = oldcnt;
 445 
 446         mutex_enter(&fip->fi_lock);
 447         urp->ur_next = fip->fi_rlist;
 448         fip->fi_rlist = urp;
 449         mutex_exit(&fip->fi_lock);
 450 }
 451 
 452 /*
 453  * Utility functions for keeping track of the active file descriptors.
 454  */
 455 void
 456 clear_stale_fd()                /* called from post_syscall() */
 457 {
 458         afd_t *afd = &curthread->t_activefd;
 459         int i;
 460 
 461         /* uninitialized is ok here, a_nfd is then zero */
 462         for (i = 0; i < afd->a_nfd; i++) {
 463                 /* assert that this should not be necessary */
 464                 ASSERT(afd->a_fd[i] == -1);
 465                 afd->a_fd[i] = -1;
 466         }
 467         afd->a_stale = 0;
 468 }
 469 
 470 void
 471 free_afd(afd_t *afd)            /* called below and from thread_free() */
 472 {
 473         int i;
 474 
 475         /* free the buffer if it was kmem_alloc()ed */
 476         if (afd->a_nfd > sizeof (afd->a_buf) / sizeof (afd->a_buf[0])) {
 477                 COUNT(afd_free);
 478                 kmem_free(afd->a_fd, afd->a_nfd * sizeof (afd->a_fd[0]));
 479         }
 480 
 481         /* (re)initialize the structure */
 482         afd->a_fd = &afd->a_buf[0];
 483         afd->a_nfd = sizeof (afd->a_buf) / sizeof (afd->a_buf[0]);
 484         afd->a_stale = 0;
 485         for (i = 0; i < afd->a_nfd; i++)
 486                 afd->a_fd[i] = -1;
 487 }
 488 
 489 static void
 490 set_active_fd(int fd)
 491 {
 492         afd_t *afd = &curthread->t_activefd;
 493         int i;
 494         int *old_fd;
 495         int old_nfd;
 496         int *new_fd;
 497         int new_nfd;
 498 
 499         if (afd->a_nfd == 0) {       /* first time initialization */
 500                 ASSERT(fd == -1);
 501                 mutex_enter(&afd->a_fdlock);
 502                 free_afd(afd);
 503                 mutex_exit(&afd->a_fdlock);
 504         }
 505 
 506         /* insert fd into vacant slot, if any */
 507         for (i = 0; i < afd->a_nfd; i++) {
 508                 if (afd->a_fd[i] == -1) {
 509                         afd->a_fd[i] = fd;
 510                         return;
 511                 }
 512         }
 513 
 514         /*
 515          * Reallocate the a_fd[] array to add one more slot.
 516          */
 517         ASSERT(fd == -1);
 518         old_nfd = afd->a_nfd;
 519         old_fd = afd->a_fd;
 520         new_nfd = old_nfd + 1;
 521         new_fd = kmem_alloc(new_nfd * sizeof (afd->a_fd[0]), KM_SLEEP);
 522         MAXFD(new_nfd);
 523         COUNT(afd_alloc);
 524 
 525         mutex_enter(&afd->a_fdlock);
 526         afd->a_fd = new_fd;
 527         afd->a_nfd = new_nfd;
 528         for (i = 0; i < old_nfd; i++)
 529                 afd->a_fd[i] = old_fd[i];
 530         afd->a_fd[i] = fd;
 531         mutex_exit(&afd->a_fdlock);
 532 
 533         if (old_nfd > sizeof (afd->a_buf) / sizeof (afd->a_buf[0])) {
 534                 COUNT(afd_free);
 535                 kmem_free(old_fd, old_nfd * sizeof (afd->a_fd[0]));
 536         }
 537 }
 538 
 539 void
 540 clear_active_fd(int fd)         /* called below and from aio.c */
 541 {
 542         afd_t *afd = &curthread->t_activefd;
 543         int i;
 544 
 545         for (i = 0; i < afd->a_nfd; i++) {
 546                 if (afd->a_fd[i] == fd) {
 547                         afd->a_fd[i] = -1;
 548                         break;
 549                 }
 550         }
 551         ASSERT(i < afd->a_nfd);           /* not found is not ok */
 552 }
 553 
 554 /*
 555  * Does this thread have this fd active?
 556  */
 557 static int
 558 is_active_fd(kthread_t *t, int fd)
 559 {
 560         afd_t *afd = &t->t_activefd;
 561         int i;
 562 
 563         ASSERT(t != curthread);
 564         mutex_enter(&afd->a_fdlock);
 565         /* uninitialized is ok here, a_nfd is then zero */
 566         for (i = 0; i < afd->a_nfd; i++) {
 567                 if (afd->a_fd[i] == fd) {
 568                         mutex_exit(&afd->a_fdlock);
 569                         return (1);
 570                 }
 571         }
 572         mutex_exit(&afd->a_fdlock);
 573         return (0);
 574 }
 575 
 576 /*
 577  * Convert a user supplied file descriptor into a pointer to a file
 578  * structure.  Only task is to check range of the descriptor (soft
 579  * resource limit was enforced at open time and shouldn't be checked
 580  * here).
 581  */
 582 file_t *
 583 getf(int fd)
 584 {
 585         uf_info_t *fip = P_FINFO(curproc);
 586         uf_entry_t *ufp;
 587         file_t *fp;
 588 
 589         if ((uint_t)fd >= fip->fi_nfiles)
 590                 return (NULL);
 591 
 592         /*
 593          * Reserve a slot in the active fd array now so we can call
 594          * set_active_fd(fd) for real below, while still inside UF_ENTER().
 595          */
 596         set_active_fd(-1);
 597 
 598         UF_ENTER(ufp, fip, fd);
 599 
 600         if ((fp = ufp->uf_file) == NULL) {
 601                 UF_EXIT(ufp);
 602 
 603                 if (fd == fip->fi_badfd && fip->fi_action > 0)
 604                         tsignal(curthread, fip->fi_action);
 605 
 606                 return (NULL);
 607         }
 608         ufp->uf_refcnt++;
 609 
 610         set_active_fd(fd);      /* record the active file descriptor */
 611 
 612         UF_EXIT(ufp);
 613 
 614         return (fp);
 615 }
 616 
 617 /*
 618  * Close whatever file currently occupies the file descriptor slot
 619  * and install the new file, usually NULL, in the file descriptor slot.
 620  * The close must complete before we release the file descriptor slot.
 621  * If newfp != NULL we only return an error if we can't allocate the
 622  * slot so the caller knows that it needs to free the filep;
 623  * in the other cases we return the error number from closef().
 624  */
 625 int
 626 closeandsetf(int fd, file_t *newfp)
 627 {
 628         proc_t *p = curproc;
 629         uf_info_t *fip = P_FINFO(p);
 630         uf_entry_t *ufp;
 631         file_t *fp;
 632         fpollinfo_t *fpip;
 633         portfd_t *pfd;
 634         int error;
 635 
 636         if ((uint_t)fd >= fip->fi_nfiles) {
 637                 if (newfp == NULL)
 638                         return (EBADF);
 639                 flist_grow(fd);
 640         }
 641 
 642         if (newfp != NULL) {
 643                 /*
 644                  * If ufp is reserved but has no file pointer, it's in the
 645                  * transition between ufalloc() and setf().  We must wait
 646                  * for this transition to complete before assigning the
 647                  * new non-NULL file pointer.
 648                  */
 649                 mutex_enter(&fip->fi_lock);
 650                 if (fd == fip->fi_badfd) {
 651                         mutex_exit(&fip->fi_lock);
 652                         if (fip->fi_action > 0)
 653                                 tsignal(curthread, fip->fi_action);
 654                         return (EBADF);
 655                 }
 656                 UF_ENTER(ufp, fip, fd);
 657                 while (ufp->uf_busy && ufp->uf_file == NULL) {
 658                         mutex_exit(&fip->fi_lock);
 659                         cv_wait_stop(&ufp->uf_wanted_cv, &ufp->uf_lock, 250);
 660                         UF_EXIT(ufp);
 661                         mutex_enter(&fip->fi_lock);
 662                         UF_ENTER(ufp, fip, fd);
 663                 }
 664                 if ((fp = ufp->uf_file) == NULL) {
 665                         ASSERT(ufp->uf_fpollinfo == NULL);
 666                         ASSERT(ufp->uf_flag == 0);
 667                         fd_reserve(fip, fd, 1);
 668                         ufp->uf_file = newfp;
 669                         UF_EXIT(ufp);
 670                         mutex_exit(&fip->fi_lock);
 671                         return (0);
 672                 }
 673                 mutex_exit(&fip->fi_lock);
 674         } else {
 675                 UF_ENTER(ufp, fip, fd);
 676                 if ((fp = ufp->uf_file) == NULL) {
 677                         UF_EXIT(ufp);
 678                         return (EBADF);
 679                 }
 680         }
 681 
 682         ASSERT(ufp->uf_busy);
 683         ufp->uf_file = NULL;
 684         ufp->uf_flag = 0;
 685 
 686         /*
 687          * If the file descriptor reference count is non-zero, then
 688          * some other lwp in the process is performing system call
 689          * activity on the file.  To avoid blocking here for a long
 690          * time (the other lwp might be in a long term sleep in its
 691          * system call), we scan all other lwps in the process to
 692          * find the ones with this fd as one of their active fds,
 693          * set their a_stale flag, and set them running if they
 694          * are in an interruptible sleep so they will emerge from
 695          * their system calls immediately.  post_syscall() will
 696          * test the a_stale flag and set errno to EBADF.
 697          */
 698         ASSERT(ufp->uf_refcnt == 0 || p->p_lwpcnt > 1);
 699         if (ufp->uf_refcnt > 0) {
 700                 kthread_t *t;
 701 
 702                 /*
 703                  * We call sprlock_proc(p) to ensure that the thread
 704                  * list will not change while we are scanning it.
 705                  * To do this, we must drop ufp->uf_lock and then
 706                  * reacquire it (so we are not holding both p->p_lock
 707                  * and ufp->uf_lock at the same time).  ufp->uf_lock
 708                  * must be held for is_active_fd() to be correct
 709                  * (set_active_fd() is called while holding ufp->uf_lock).
 710                  *
 711                  * This is a convoluted dance, but it is better than
 712                  * the old brute-force method of stopping every thread
 713                  * in the process by calling holdlwps(SHOLDFORK1).
 714                  */
 715 
 716                 UF_EXIT(ufp);
 717                 COUNT(afd_wait);
 718 
 719                 mutex_enter(&p->p_lock);
 720                 sprlock_proc(p);
 721                 mutex_exit(&p->p_lock);
 722 
 723                 UF_ENTER(ufp, fip, fd);
 724                 ASSERT(ufp->uf_file == NULL);
 725 
 726                 if (ufp->uf_refcnt > 0) {
 727                         for (t = curthread->t_forw;
 728                             t != curthread;
 729                             t = t->t_forw) {
 730                                 if (is_active_fd(t, fd)) {
 731                                         thread_lock(t);
 732                                         t->t_activefd.a_stale = 1;
 733                                         t->t_post_sys = 1;
 734                                         if (ISWAKEABLE(t))
 735                                                 setrun_locked(t);
 736                                         thread_unlock(t);
 737                                 }
 738                         }
 739                 }
 740 
 741                 UF_EXIT(ufp);
 742 
 743                 mutex_enter(&p->p_lock);
 744                 sprunlock(p);
 745 
 746                 UF_ENTER(ufp, fip, fd);
 747                 ASSERT(ufp->uf_file == NULL);
 748         }
 749 
 750         /*
 751          * Wait for other lwps to stop using this file descriptor.
 752          */
 753         while (ufp->uf_refcnt > 0) {
 754                 cv_wait_stop(&ufp->uf_closing_cv, &ufp->uf_lock, 250);
 755                 /*
 756                  * cv_wait_stop() drops ufp->uf_lock, so the file list
 757                  * can change.  Drop the lock on our (possibly) stale
 758                  * ufp and let UF_ENTER() find and lock the current ufp.
 759                  */
 760                 UF_EXIT(ufp);
 761                 UF_ENTER(ufp, fip, fd);
 762         }
 763 
 764 #ifdef DEBUG
 765         /*
 766          * catch a watchfd on device's pollhead list but not on fpollinfo list
 767          */
 768         if (ufp->uf_fpollinfo != NULL)
 769                 checkwfdlist(fp->f_vnode, ufp->uf_fpollinfo);
 770 #endif  /* DEBUG */
 771 
 772         /*
 773          * We may need to cleanup some cached poll states in t_pollstate
 774          * before the fd can be reused. It is important that we don't
 775          * access a stale thread structure. We will do the cleanup in two
 776          * phases to avoid deadlock and holding uf_lock for too long.
 777          * In phase 1, hold the uf_lock and call pollblockexit() to set
 778          * state in t_pollstate struct so that a thread does not exit on
 779          * us. In phase 2, we drop the uf_lock and call pollcacheclean().
 780          */
 781         pfd = ufp->uf_portfd;
 782         ufp->uf_portfd = NULL;
 783         fpip = ufp->uf_fpollinfo;
 784         ufp->uf_fpollinfo = NULL;
 785         if (fpip != NULL)
 786                 pollblockexit(fpip);
 787         UF_EXIT(ufp);
 788         if (fpip != NULL)
 789                 pollcacheclean(fpip, fd);
 790         if (pfd)
 791                 port_close_fd(pfd);
 792 
 793         /*
 794          * Keep the file descriptor entry reserved across the closef().
 795          */
 796         error = closef(fp);
 797 
 798         setf(fd, newfp);
 799 
 800         /* Only return closef() error when closing is all we do */
 801         return (newfp == NULL ? error : 0);
 802 }
 803 
 804 /*
 805  * Decrement uf_refcnt; wakeup anyone waiting to close the file.
 806  */
 807 void
 808 releasef(int fd)
 809 {
 810         uf_info_t *fip = P_FINFO(curproc);
 811         uf_entry_t *ufp;
 812 
 813         UF_ENTER(ufp, fip, fd);
 814         ASSERT(ufp->uf_refcnt > 0);
 815         clear_active_fd(fd);    /* clear the active file descriptor */
 816         if (--ufp->uf_refcnt == 0)
 817                 cv_broadcast(&ufp->uf_closing_cv);
 818         UF_EXIT(ufp);
 819 }
 820 
 821 /*
 822  * Identical to releasef() but can be called from another process.
 823  */
 824 void
 825 areleasef(int fd, uf_info_t *fip)
 826 {
 827         uf_entry_t *ufp;
 828 
 829         UF_ENTER(ufp, fip, fd);
 830         ASSERT(ufp->uf_refcnt > 0);
 831         if (--ufp->uf_refcnt == 0)
 832                 cv_broadcast(&ufp->uf_closing_cv);
 833         UF_EXIT(ufp);
 834 }
 835 
 836 /*
 837  * Duplicate all file descriptors across a fork.
 838  */
 839 void
 840 flist_fork(proc_t *pp, proc_t *cp)
 841 {
 842         int fd, nfiles;
 843         uf_entry_t *pufp, *cufp;
 844 
 845         uf_info_t *pfip = P_FINFO(pp);
 846         uf_info_t *cfip = P_FINFO(cp);
 847 
 848         mutex_init(&cfip->fi_lock, NULL, MUTEX_DEFAULT, NULL);
 849         cfip->fi_rlist = NULL;
 850 
 851         /*
 852          * We don't need to hold fi_lock because all other lwp's in the
 853          * parent have been held.
 854          */
 855         cfip->fi_nfiles = nfiles = flist_minsize(pfip);
 856 
 857         cfip->fi_list = kmem_zalloc(nfiles * sizeof (uf_entry_t), KM_SLEEP);
 858 
 859         for (fd = 0, pufp = pfip->fi_list, cufp = cfip->fi_list; fd < nfiles;
 860             fd++, pufp++, cufp++) {
 861                 cufp->uf_file = pufp->uf_file;
 862                 cufp->uf_alloc = pufp->uf_alloc;
 863                 cufp->uf_flag = pufp->uf_flag;
 864                 cufp->uf_busy = pufp->uf_busy;
 865 
 866                 if (cufp->uf_file != NULL && cufp->uf_file->f_vnode != NULL) {
 867                         VOP_IOCTL(cufp->uf_file->f_vnode, F_FORKED,
 868                                 (intptr_t)cp,
 869                                 FKIOCTL,
 870                                 kcred, NULL, NULL);
 871                 }
 872 
 873                 if (pufp->uf_file == NULL) {
 874                         ASSERT(pufp->uf_flag == 0);
 875                         if (pufp->uf_busy) {
 876                                 /*
 877                                  * Grab locks to appease ASSERTs in fd_reserve
 878                                  */
 879                                 mutex_enter(&cfip->fi_lock);
 880                                 mutex_enter(&cufp->uf_lock);
 881                                 fd_reserve(cfip, fd, -1);
 882                                 mutex_exit(&cufp->uf_lock);
 883                                 mutex_exit(&cfip->fi_lock);
 884                         }
 885                 }
 886         }
 887 }
 888 
 889 /*
 890  * Close all open file descriptors for the current process.
 891  * This is only called from exit(), which is single-threaded,
 892  * so we don't need any locking.
 893  */
 894 void
 895 closeall(uf_info_t *fip)
 896 {
 897         int fd;
 898         file_t *fp;
 899         uf_entry_t *ufp;
 900 
 901         ufp = fip->fi_list;
 902         for (fd = 0; fd < fip->fi_nfiles; fd++, ufp++) {
 903                 if ((fp = ufp->uf_file) != NULL) {
 904                         ufp->uf_file = NULL;
 905                         if (ufp->uf_portfd != NULL) {
 906                                 portfd_t *pfd;
 907                                 /* remove event port association */
 908                                 pfd = ufp->uf_portfd;
 909                                 ufp->uf_portfd = NULL;
 910                                 port_close_fd(pfd);
 911                         }
 912                         ASSERT(ufp->uf_fpollinfo == NULL);
 913                         (void) closef(fp);
 914                 }
 915         }
 916 
 917         kmem_free(fip->fi_list, fip->fi_nfiles * sizeof (uf_entry_t));
 918         fip->fi_list = NULL;
 919         fip->fi_nfiles = 0;
 920         while (fip->fi_rlist != NULL) {
 921                 uf_rlist_t *urp = fip->fi_rlist;
 922                 fip->fi_rlist = urp->ur_next;
 923                 kmem_free(urp->ur_list, urp->ur_nfiles * sizeof (uf_entry_t));
 924                 kmem_free(urp, sizeof (uf_rlist_t));
 925         }
 926 }
 927 
 928 /*
 929  * Internal form of close.  Decrement reference count on file
 930  * structure.  Decrement reference count on the vnode following
 931  * removal of the referencing file structure.
 932  */
 933 int
 934 closef(file_t *fp)
 935 {
 936         vnode_t *vp;
 937         int error;
 938         int count;
 939         int flag;
 940         offset_t offset;
 941 
 942         /*
 943          * audit close of file (may be exit)
 944          */
 945         if (AU_AUDITING())
 946                 audit_closef(fp);
 947         ASSERT(MUTEX_NOT_HELD(&P_FINFO(curproc)->fi_lock));
 948 
 949         mutex_enter(&fp->f_tlock);
 950 
 951         ASSERT(fp->f_count > 0);
 952 
 953         count = fp->f_count--;
 954         flag = fp->f_flag;
 955         offset = fp->f_offset;
 956 
 957         vp = fp->f_vnode;
 958         if (vp != NULL)
 959                 VOP_IOCTL(vp, F_CLOSED, (intptr_t)ttoproc(curthread),
 960                         FKIOCTL, kcred, NULL, NULL);
 961 
 962         error = VOP_CLOSE(vp, flag, count, offset, fp->f_cred, NULL);
 963 
 964         if (count > 1) {
 965                 mutex_exit(&fp->f_tlock);
 966                 return (error);
 967         }
 968         ASSERT(fp->f_count == 0);
 969         mutex_exit(&fp->f_tlock);
 970 
 971         /*
 972          * If DTrace has getf() subroutines active, it will set dtrace_closef
 973          * to point to code that implements a barrier with respect to probe
 974          * context.  This must be called before the file_t is freed (and the
 975          * vnode that it refers to is released) -- but it must be after the
 976          * file_t has been removed from the uf_entry_t.  That is, there must
 977          * be no way for a racing getf() in probe context to yield the fp that
 978          * we're operating upon.
 979          */
 980         if (dtrace_closef != NULL)
 981                 (*dtrace_closef)();
 982 
 983         VN_RELE(vp);
 984         /*
 985          * deallocate resources to audit_data
 986          */
 987         if (audit_active)
 988                 audit_unfalloc(fp);
 989         crfree(fp->f_cred);
 990         kmem_cache_free(file_cache, fp);
 991         return (error);
 992 }
 993 
 994 /*
 995  * This is a combination of ufalloc() and setf().
 996  */
 997 int
 998 ufalloc_file(int start, file_t *fp)
 999 {
1000         proc_t *p = curproc;
1001         uf_info_t *fip = P_FINFO(p);
1002         int filelimit;
1003         uf_entry_t *ufp;
1004         int nfiles;
1005         int fd;
1006 
1007         /*
1008          * Assertion is to convince the correctness of the following
1009          * assignment for filelimit after casting to int.
1010          */
1011         ASSERT(p->p_fno_ctl <= INT_MAX);
1012         filelimit = (int)p->p_fno_ctl;
1013 
1014         for (;;) {
1015                 mutex_enter(&fip->fi_lock);
1016                 fd = fd_find(fip, start);
1017                 if (fd >= 0 && fd == fip->fi_badfd) {
1018                         start = fd + 1;
1019                         mutex_exit(&fip->fi_lock);
1020                         continue;
1021                 }
1022                 if ((uint_t)fd < filelimit)
1023                         break;
1024                 if (fd >= filelimit) {
1025                         mutex_exit(&fip->fi_lock);
1026                         mutex_enter(&p->p_lock);
1027                         (void) rctl_action(rctlproc_legacy[RLIMIT_NOFILE],
1028                             p->p_rctls, p, RCA_SAFE);
1029                         mutex_exit(&p->p_lock);
1030                         return (-1);
1031                 }
1032                 /* fd_find() returned -1 */
1033                 nfiles = fip->fi_nfiles;
1034                 mutex_exit(&fip->fi_lock);
1035                 flist_grow(MAX(start, nfiles));
1036         }
1037 
1038         UF_ENTER(ufp, fip, fd);
1039         fd_reserve(fip, fd, 1);
1040         ASSERT(ufp->uf_file == NULL);
1041         ufp->uf_file = fp;
1042         UF_EXIT(ufp);
1043         mutex_exit(&fip->fi_lock);
1044         return (fd);
1045 }
1046 
1047 /*
1048  * Allocate a user file descriptor greater than or equal to "start".
1049  */
1050 int
1051 ufalloc(int start)
1052 {
1053         return (ufalloc_file(start, NULL));
1054 }
1055 
1056 /*
1057  * Check that a future allocation of count fds on proc p has a good
1058  * chance of succeeding.  If not, do rctl processing as if we'd failed
1059  * the allocation.
1060  *
1061  * Our caller must guarantee that p cannot disappear underneath us.
1062  */
1063 int
1064 ufcanalloc(proc_t *p, uint_t count)
1065 {
1066         uf_info_t *fip = P_FINFO(p);
1067         int filelimit;
1068         int current;
1069 
1070         if (count == 0)
1071                 return (1);
1072 
1073         ASSERT(p->p_fno_ctl <= INT_MAX);
1074         filelimit = (int)p->p_fno_ctl;
1075 
1076         mutex_enter(&fip->fi_lock);
1077         current = flist_nalloc(fip);            /* # of in-use descriptors */
1078         mutex_exit(&fip->fi_lock);
1079 
1080         /*
1081          * If count is a positive integer, the worst that can happen is
1082          * an overflow to a negative value, which is caught by the >= 0 check.
1083          */
1084         current += count;
1085         if (count <= INT_MAX && current >= 0 && current <= filelimit)
1086                 return (1);
1087 
1088         mutex_enter(&p->p_lock);
1089         (void) rctl_action(rctlproc_legacy[RLIMIT_NOFILE],
1090             p->p_rctls, p, RCA_SAFE);
1091         mutex_exit(&p->p_lock);
1092         return (0);
1093 }
1094 
1095 /*
1096  * Allocate a user file descriptor and a file structure.
1097  * Initialize the descriptor to point at the file structure.
1098  * If fdp is NULL, the user file descriptor will not be allocated.
1099  */
1100 int
1101 falloc(vnode_t *vp, int flag, file_t **fpp, int *fdp)
1102 {
1103         file_t *fp;
1104         int fd;
1105 
1106         if (fdp) {
1107                 if ((fd = ufalloc(0)) == -1)
1108                         return (EMFILE);
1109         }
1110         fp = kmem_cache_alloc(file_cache, KM_SLEEP);
1111         /*
1112          * Note: falloc returns the fp locked
1113          */
1114         mutex_enter(&fp->f_tlock);
1115         fp->f_count = 1;
1116         fp->f_flag = (ushort_t)flag;
1117         fp->f_flag2 = (flag & (FSEARCH|FEXEC)) >> 16;
1118         fp->f_vnode = vp;
1119         fp->f_offset = 0;
1120         fp->f_audit_data = 0;
1121         crhold(fp->f_cred = CRED());
1122         /*
1123          * allocate resources to audit_data
1124          */
1125         if (audit_active)
1126                 audit_falloc(fp);
1127         *fpp = fp;
1128         if (fdp)
1129                 *fdp = fd;
1130         return (0);
1131 }
1132 
1133 /*ARGSUSED*/
1134 static int
1135 file_cache_constructor(void *buf, void *cdrarg, int kmflags)
1136 {
1137         file_t *fp = buf;
1138 
1139         mutex_init(&fp->f_tlock, NULL, MUTEX_DEFAULT, NULL);
1140         return (0);
1141 }
1142 
1143 /*ARGSUSED*/
1144 static void
1145 file_cache_destructor(void *buf, void *cdrarg)
1146 {
1147         file_t *fp = buf;
1148 
1149         mutex_destroy(&fp->f_tlock);
1150 }
1151 
1152 void
1153 finit()
1154 {
1155         file_cache = kmem_cache_create("file_cache", sizeof (file_t), 0,
1156             file_cache_constructor, file_cache_destructor, NULL, NULL, NULL, 0);
1157 }
1158 
1159 void
1160 unfalloc(file_t *fp)
1161 {
1162         ASSERT(MUTEX_HELD(&fp->f_tlock));
1163         if (--fp->f_count <= 0) {
1164                 /*
1165                  * deallocate resources to audit_data
1166                  */
1167                 if (audit_active)
1168                         audit_unfalloc(fp);
1169                 crfree(fp->f_cred);
1170                 mutex_exit(&fp->f_tlock);
1171                 kmem_cache_free(file_cache, fp);
1172         } else
1173                 mutex_exit(&fp->f_tlock);
1174 }
1175 
1176 /*
1177  * Given a file descriptor, set the user's
1178  * file pointer to the given parameter.
1179  */
1180 void
1181 setf(int fd, file_t *fp)
1182 {
1183         uf_info_t *fip = P_FINFO(curproc);
1184         uf_entry_t *ufp;
1185 
1186         if (AU_AUDITING())
1187                 audit_setf(fp, fd);
1188 
1189         if (fp == NULL) {
1190                 mutex_enter(&fip->fi_lock);
1191                 UF_ENTER(ufp, fip, fd);
1192                 fd_reserve(fip, fd, -1);
1193                 mutex_exit(&fip->fi_lock);
1194         } else {
1195                 UF_ENTER(ufp, fip, fd);
1196                 ASSERT(ufp->uf_busy);
1197         }
1198         ASSERT(ufp->uf_fpollinfo == NULL);
1199         ASSERT(ufp->uf_flag == 0);
1200         ufp->uf_file = fp;
1201         cv_broadcast(&ufp->uf_wanted_cv);
1202         UF_EXIT(ufp);
1203 }
1204 
1205 /*
1206  * Given a file descriptor, return the file table flags, plus,
1207  * if this is a socket in asynchronous mode, the FASYNC flag.
1208  * getf() may or may not have been called before calling f_getfl().
1209  */
1210 int
1211 f_getfl(int fd, int *flagp)
1212 {
1213         uf_info_t *fip = P_FINFO(curproc);
1214         uf_entry_t *ufp;
1215         file_t *fp;
1216         int error;
1217 
1218         if ((uint_t)fd >= fip->fi_nfiles)
1219                 error = EBADF;
1220         else {
1221                 UF_ENTER(ufp, fip, fd);
1222                 if ((fp = ufp->uf_file) == NULL)
1223                         error = EBADF;
1224                 else {
1225                         vnode_t *vp = fp->f_vnode;
1226                         int flag = fp->f_flag | (fp->f_flag2 << 16);
1227 
1228                         /*
1229                          * BSD fcntl() FASYNC compatibility.
1230                          */
1231                         if (vp->v_type == VSOCK)
1232                                 flag |= sock_getfasync(vp);
1233                         *flagp = flag;
1234                         error = 0;
1235                 }
1236                 UF_EXIT(ufp);
1237         }
1238 
1239         return (error);
1240 }
1241 
1242 /*
1243  * Given a file descriptor, return the user's file flags.
1244  * Force the FD_CLOEXEC flag for writable self-open /proc files.
1245  * getf() may or may not have been called before calling f_getfd_error().
1246  */
1247 int
1248 f_getfd_error(int fd, int *flagp)
1249 {
1250         uf_info_t *fip = P_FINFO(curproc);
1251         uf_entry_t *ufp;
1252         file_t *fp;
1253         int flag;
1254         int error;
1255 
1256         if ((uint_t)fd >= fip->fi_nfiles)
1257                 error = EBADF;
1258         else {
1259                 UF_ENTER(ufp, fip, fd);
1260                 if ((fp = ufp->uf_file) == NULL)
1261                         error = EBADF;
1262                 else {
1263                         flag = ufp->uf_flag;
1264                         if ((fp->f_flag & FWRITE) && pr_isself(fp->f_vnode))
1265                                 flag |= FD_CLOEXEC;
1266                         *flagp = flag;
1267                         error = 0;
1268                 }
1269                 UF_EXIT(ufp);
1270         }
1271 
1272         return (error);
1273 }
1274 
1275 /*
1276  * getf() must have been called before calling f_getfd().
1277  */
1278 char
1279 f_getfd(int fd)
1280 {
1281         int flag = 0;
1282         (void) f_getfd_error(fd, &flag);
1283         return ((char)flag);
1284 }
1285 
1286 /*
1287  * Given a file descriptor and file flags, set the user's file flags.
1288  * At present, the only valid flag is FD_CLOEXEC.
1289  * getf() may or may not have been called before calling f_setfd_error().
1290  */
1291 int
1292 f_setfd_error(int fd, int flags)
1293 {
1294         uf_info_t *fip = P_FINFO(curproc);
1295         uf_entry_t *ufp;
1296         int error;
1297 
1298         if ((uint_t)fd >= fip->fi_nfiles)
1299                 error = EBADF;
1300         else {
1301                 UF_ENTER(ufp, fip, fd);
1302                 if (ufp->uf_file == NULL)
1303                         error = EBADF;
1304                 else {
1305                         ufp->uf_flag = flags & FD_CLOEXEC;
1306                         error = 0;
1307                 }
1308                 UF_EXIT(ufp);
1309         }
1310         return (error);
1311 }
1312 
1313 void
1314 f_setfd(int fd, char flags)
1315 {
1316         (void) f_setfd_error(fd, flags);
1317 }
1318 
1319 #define BADFD_MIN       3
1320 #define BADFD_MAX       255
1321 
1322 /*
1323  * Attempt to allocate a file descriptor which is bad and which
1324  * is "poison" to the application.  It cannot be closed (except
1325  * on exec), allocated for a different use, etc.
1326  */
1327 int
1328 f_badfd(int start, int *fdp, int action)
1329 {
1330         int fdr;
1331         int badfd;
1332         uf_info_t *fip = P_FINFO(curproc);
1333 
1334 #ifdef _LP64
1335         /* No restrictions on 64 bit _file */
1336         if (get_udatamodel() != DATAMODEL_ILP32)
1337                 return (EINVAL);
1338 #endif
1339 
1340         if (start > BADFD_MAX || start < BADFD_MIN)
1341                 return (EINVAL);
1342 
1343         if (action >= NSIG || action < 0)
1344                 return (EINVAL);
1345 
1346         mutex_enter(&fip->fi_lock);
1347         badfd = fip->fi_badfd;
1348         mutex_exit(&fip->fi_lock);
1349 
1350         if (badfd != -1)
1351                 return (EAGAIN);
1352 
1353         fdr = ufalloc(start);
1354 
1355         if (fdr > BADFD_MAX) {
1356                 setf(fdr, NULL);
1357                 return (EMFILE);
1358         }
1359         if (fdr < 0)
1360                 return (EMFILE);
1361 
1362         mutex_enter(&fip->fi_lock);
1363         if (fip->fi_badfd != -1) {
1364                 /* Lost race */
1365                 mutex_exit(&fip->fi_lock);
1366                 setf(fdr, NULL);
1367                 return (EAGAIN);
1368         }
1369         fip->fi_action = action;
1370         fip->fi_badfd = fdr;
1371         mutex_exit(&fip->fi_lock);
1372         setf(fdr, NULL);
1373 
1374         *fdp = fdr;
1375 
1376         return (0);
1377 }
1378 
1379 /*
1380  * Allocate a file descriptor and assign it to the vnode "*vpp",
1381  * performing the usual open protocol upon it and returning the
1382  * file descriptor allocated.  It is the responsibility of the
1383  * caller to dispose of "*vpp" if any error occurs.
1384  */
1385 int
1386 fassign(vnode_t **vpp, int mode, int *fdp)
1387 {
1388         file_t *fp;
1389         int error;
1390         int fd;
1391 
1392         if (error = falloc((vnode_t *)NULL, mode, &fp, &fd))
1393                 return (error);
1394         if (error = VOP_OPEN(vpp, mode, fp->f_cred, NULL)) {
1395                 setf(fd, NULL);
1396                 unfalloc(fp);
1397                 return (error);
1398         }
1399         fp->f_vnode = *vpp;
1400         mutex_exit(&fp->f_tlock);
1401         /*
1402          * Fill in the slot falloc reserved.
1403          */
1404         setf(fd, fp);
1405         *fdp = fd;
1406         return (0);
1407 }
1408 
1409 /*
1410  * When a process forks it must increment the f_count of all file pointers
1411  * since there is a new process pointing at them.  fcnt_add(fip, 1) does this.
1412  * Since we are called when there is only 1 active lwp we don't need to
1413  * hold fi_lock or any uf_lock.  If the fork fails, fork_fail() calls
1414  * fcnt_add(fip, -1) to restore the counts.
1415  */
1416 void
1417 fcnt_add(uf_info_t *fip, int incr)
1418 {
1419         int i;
1420         uf_entry_t *ufp;
1421         file_t *fp;
1422 
1423         ufp = fip->fi_list;
1424         for (i = 0; i < fip->fi_nfiles; i++, ufp++) {
1425                 if ((fp = ufp->uf_file) != NULL) {
1426                         mutex_enter(&fp->f_tlock);
1427                         ASSERT((incr == 1 && fp->f_count >= 1) ||
1428                             (incr == -1 && fp->f_count >= 2));
1429                         fp->f_count += incr;
1430                         mutex_exit(&fp->f_tlock);
1431                 }
1432         }
1433 }
1434 
1435 /*
1436  * This is called from exec to close all fd's that have the FD_CLOEXEC flag
1437  * set and also to close all self-open for write /proc file descriptors.
1438  */
1439 void
1440 close_exec(uf_info_t *fip)
1441 {
1442         int fd;
1443         file_t *fp;
1444         fpollinfo_t *fpip;
1445         uf_entry_t *ufp;
1446         portfd_t *pfd;
1447 
1448         ufp = fip->fi_list;
1449         for (fd = 0; fd < fip->fi_nfiles; fd++, ufp++) {
1450                 if ((fp = ufp->uf_file) != NULL &&
1451                     ((ufp->uf_flag & FD_CLOEXEC) ||
1452                     ((fp->f_flag & FWRITE) && pr_isself(fp->f_vnode)))) {
1453                         fpip = ufp->uf_fpollinfo;
1454                         mutex_enter(&fip->fi_lock);
1455                         mutex_enter(&ufp->uf_lock);
1456                         fd_reserve(fip, fd, -1);
1457                         mutex_exit(&fip->fi_lock);
1458                         ufp->uf_file = NULL;
1459                         ufp->uf_fpollinfo = NULL;
1460                         ufp->uf_flag = 0;
1461                         /*
1462                          * We may need to cleanup some cached poll states
1463                          * in t_pollstate before the fd can be reused. It
1464                          * is important that we don't access a stale thread
1465                          * structure. We will do the cleanup in two
1466                          * phases to avoid deadlock and holding uf_lock for
1467                          * too long. In phase 1, hold the uf_lock and call
1468                          * pollblockexit() to set state in t_pollstate struct
1469                          * so that a thread does not exit on us. In phase 2,
1470                          * we drop the uf_lock and call pollcacheclean().
1471                          */
1472                         pfd = ufp->uf_portfd;
1473                         ufp->uf_portfd = NULL;
1474                         if (fpip != NULL)
1475                                 pollblockexit(fpip);
1476                         mutex_exit(&ufp->uf_lock);
1477                         if (fpip != NULL)
1478                                 pollcacheclean(fpip, fd);
1479                         if (pfd)
1480                                 port_close_fd(pfd);
1481                         (void) closef(fp);
1482                 }
1483         }
1484 
1485         /* Reset bad fd */
1486         fip->fi_badfd = -1;
1487         fip->fi_action = -1;
1488 }
1489 
1490 /*
1491  * Utility function called by most of the *at() system call interfaces.
1492  *
1493  * Generate a starting vnode pointer for an (fd, path) pair where 'fd'
1494  * is an open file descriptor for a directory to be used as the starting
1495  * point for the lookup of the relative pathname 'path' (or, if path is
1496  * NULL, generate a vnode pointer for the direct target of the operation).
1497  *
1498  * If we successfully return a non-NULL startvp, it has been the target
1499  * of VN_HOLD() and the caller must call VN_RELE() on it.
1500  */
1501 int
1502 fgetstartvp(int fd, char *path, vnode_t **startvpp)
1503 {
1504         vnode_t         *startvp;
1505         file_t          *startfp;
1506         char            startchar;
1507 
1508         if (fd == AT_FDCWD && path == NULL)
1509                 return (EFAULT);
1510 
1511         if (fd == AT_FDCWD) {
1512                 /*
1513                  * Start from the current working directory.
1514                  */
1515                 startvp = NULL;
1516         } else {
1517                 if (path == NULL)
1518                         startchar = '\0';
1519                 else if (copyin(path, &startchar, sizeof (char)))
1520                         return (EFAULT);
1521 
1522                 if (startchar == '/') {
1523                         /*
1524                          * 'path' is an absolute pathname.
1525                          */
1526                         startvp = NULL;
1527                 } else {
1528                         /*
1529                          * 'path' is a relative pathname or we will
1530                          * be applying the operation to 'fd' itself.
1531                          */
1532                         if ((startfp = getf(fd)) == NULL)
1533                                 return (EBADF);
1534                         startvp = startfp->f_vnode;
1535                         VN_HOLD(startvp);
1536                         releasef(fd);
1537                 }
1538         }
1539         *startvpp = startvp;
1540         return (0);
1541 }
1542 
1543 /*
1544  * Called from fchownat() and fchmodat() to set ownership and mode.
1545  * The contents of *vap must be set before calling here.
1546  */
1547 int
1548 fsetattrat(int fd, char *path, int flags, struct vattr *vap)
1549 {
1550         vnode_t         *startvp;
1551         vnode_t         *vp;
1552         int             error;
1553 
1554         /*
1555          * Since we are never called to set the size of a file, we don't
1556          * need to check for non-blocking locks (via nbl_need_check(vp)).
1557          */
1558         ASSERT(!(vap->va_mask & AT_SIZE));
1559 
1560         if ((error = fgetstartvp(fd, path, &startvp)) != 0)
1561                 return (error);
1562         if (AU_AUDITING() && startvp != NULL)
1563                 audit_setfsat_path(1);
1564 
1565         /*
1566          * Do lookup for fchownat/fchmodat when path not NULL
1567          */
1568         if (path != NULL) {
1569                 if (error = lookupnameat(path, UIO_USERSPACE,
1570                     (flags == AT_SYMLINK_NOFOLLOW) ?
1571                     NO_FOLLOW : FOLLOW,
1572                     NULLVPP, &vp, startvp)) {
1573                         if (startvp != NULL)
1574                                 VN_RELE(startvp);
1575                         return (error);
1576                 }
1577         } else {
1578                 vp = startvp;
1579                 ASSERT(vp);
1580                 VN_HOLD(vp);
1581         }
1582 
1583         if (vn_is_readonly(vp)) {
1584                 error = EROFS;
1585         } else {
1586                 error = VOP_SETATTR(vp, vap, 0, CRED(), NULL);
1587         }
1588 
1589         if (startvp != NULL)
1590                 VN_RELE(startvp);
1591         VN_RELE(vp);
1592 
1593         return (error);
1594 }
1595 
1596 /*
1597  * Return true if the given vnode is referenced by any
1598  * entry in the current process's file descriptor table.
1599  */
1600 int
1601 fisopen(vnode_t *vp)
1602 {
1603         int fd;
1604         file_t *fp;
1605         vnode_t *ovp;
1606         uf_info_t *fip = P_FINFO(curproc);
1607         uf_entry_t *ufp;
1608 
1609         mutex_enter(&fip->fi_lock);
1610         for (fd = 0; fd < fip->fi_nfiles; fd++) {
1611                 UF_ENTER(ufp, fip, fd);
1612                 if ((fp = ufp->uf_file) != NULL &&
1613                     (ovp = fp->f_vnode) != NULL && VN_CMP(vp, ovp)) {
1614                         UF_EXIT(ufp);
1615                         mutex_exit(&fip->fi_lock);
1616                         return (1);
1617                 }
1618                 UF_EXIT(ufp);
1619         }
1620         mutex_exit(&fip->fi_lock);
1621         return (0);
1622 }
1623 
1624 /*
1625  * Return zero if at least one file currently open (by curproc) shouldn't be
1626  * allowed to change zones.
1627  */
1628 int
1629 files_can_change_zones(void)
1630 {
1631         int fd;
1632         file_t *fp;
1633         uf_info_t *fip = P_FINFO(curproc);
1634         uf_entry_t *ufp;
1635 
1636         mutex_enter(&fip->fi_lock);
1637         for (fd = 0; fd < fip->fi_nfiles; fd++) {
1638                 UF_ENTER(ufp, fip, fd);
1639                 if ((fp = ufp->uf_file) != NULL &&
1640                     !vn_can_change_zones(fp->f_vnode)) {
1641                         UF_EXIT(ufp);
1642                         mutex_exit(&fip->fi_lock);
1643                         return (0);
1644                 }
1645                 UF_EXIT(ufp);
1646         }
1647         mutex_exit(&fip->fi_lock);
1648         return (1);
1649 }
1650 
1651 #ifdef DEBUG
1652 
1653 /*
1654  * The following functions are only used in ASSERT()s elsewhere.
1655  * They do not modify the state of the system.
1656  */
1657 
1658 /*
1659  * Return true (1) if the current thread is in the fpollinfo
1660  * list for this file descriptor, else false (0).
1661  */
1662 static int
1663 curthread_in_plist(uf_entry_t *ufp)
1664 {
1665         fpollinfo_t *fpip;
1666 
1667         ASSERT(MUTEX_HELD(&ufp->uf_lock));
1668         for (fpip = ufp->uf_fpollinfo; fpip; fpip = fpip->fp_next)
1669                 if (fpip->fp_thread == curthread)
1670                         return (1);
1671         return (0);
1672 }
1673 
1674 /*
1675  * Sanity check to make sure that after lwp_exit(),
1676  * curthread does not appear on any fd's fpollinfo list.
1677  */
1678 void
1679 checkfpollinfo(void)
1680 {
1681         int fd;
1682         uf_info_t *fip = P_FINFO(curproc);
1683         uf_entry_t *ufp;
1684 
1685         mutex_enter(&fip->fi_lock);
1686         for (fd = 0; fd < fip->fi_nfiles; fd++) {
1687                 UF_ENTER(ufp, fip, fd);
1688                 ASSERT(!curthread_in_plist(ufp));
1689                 UF_EXIT(ufp);
1690         }
1691         mutex_exit(&fip->fi_lock);
1692 }
1693 
1694 /*
1695  * Return true (1) if the current thread is in the fpollinfo
1696  * list for this file descriptor, else false (0).
1697  * This is the same as curthread_in_plist(),
1698  * but is called w/o holding uf_lock.
1699  */
1700 int
1701 infpollinfo(int fd)
1702 {
1703         uf_info_t *fip = P_FINFO(curproc);
1704         uf_entry_t *ufp;
1705         int rc;
1706 
1707         UF_ENTER(ufp, fip, fd);
1708         rc = curthread_in_plist(ufp);
1709         UF_EXIT(ufp);
1710         return (rc);
1711 }
1712 
1713 #endif  /* DEBUG */
1714 
1715 /*
1716  * Add the curthread to fpollinfo list, meaning this fd is currently in the
1717  * thread's poll cache. Each lwp polling this file descriptor should call
1718  * this routine once.
1719  */
1720 void
1721 addfpollinfo(int fd)
1722 {
1723         struct uf_entry *ufp;
1724         fpollinfo_t *fpip;
1725         uf_info_t *fip = P_FINFO(curproc);
1726 
1727         fpip = kmem_zalloc(sizeof (fpollinfo_t), KM_SLEEP);
1728         fpip->fp_thread = curthread;
1729         UF_ENTER(ufp, fip, fd);
1730         /*
1731          * Assert we are not already on the list, that is, that
1732          * this lwp did not call addfpollinfo twice for the same fd.
1733          */
1734         ASSERT(!curthread_in_plist(ufp));
1735         /*
1736          * addfpollinfo is always done inside the getf/releasef pair.
1737          */
1738         ASSERT(ufp->uf_refcnt >= 1);
1739         fpip->fp_next = ufp->uf_fpollinfo;
1740         ufp->uf_fpollinfo = fpip;
1741         UF_EXIT(ufp);
1742 }
1743 
1744 /*
1745  * Delete curthread from fpollinfo list if it is there.
1746  */
1747 void
1748 delfpollinfo(int fd)
1749 {
1750         struct uf_entry *ufp;
1751         struct fpollinfo *fpip;
1752         struct fpollinfo **fpipp;
1753         uf_info_t *fip = P_FINFO(curproc);
1754 
1755         UF_ENTER(ufp, fip, fd);
1756         for (fpipp = &ufp->uf_fpollinfo;
1757             (fpip = *fpipp) != NULL;
1758             fpipp = &fpip->fp_next) {
1759                 if (fpip->fp_thread == curthread) {
1760                         *fpipp = fpip->fp_next;
1761                         kmem_free(fpip, sizeof (fpollinfo_t));
1762                         break;
1763                 }
1764         }
1765         /*
1766          * Assert that we are not still on the list, that is, that
1767          * this lwp did not call addfpollinfo twice for the same fd.
1768          */
1769         ASSERT(!curthread_in_plist(ufp));
1770         UF_EXIT(ufp);
1771 }
1772 
1773 /*
1774  * fd is associated with a port. pfd is a pointer to the fd entry in the
1775  * cache of the port.
1776  */
1777 
1778 void
1779 addfd_port(int fd, portfd_t *pfd)
1780 {
1781         struct uf_entry *ufp;
1782         uf_info_t *fip = P_FINFO(curproc);
1783 
1784         UF_ENTER(ufp, fip, fd);
1785         /*
1786          * addfd_port is always done inside the getf/releasef pair.
1787          */
1788         ASSERT(ufp->uf_refcnt >= 1);
1789         if (ufp->uf_portfd == NULL) {
1790                 /* first entry */
1791                 ufp->uf_portfd = pfd;
1792                 pfd->pfd_next = NULL;
1793         } else {
1794                 pfd->pfd_next = ufp->uf_portfd;
1795                 ufp->uf_portfd = pfd;
1796                 pfd->pfd_next->pfd_prev = pfd;
1797         }
1798         UF_EXIT(ufp);
1799 }
1800 
1801 void
1802 delfd_port(int fd, portfd_t *pfd)
1803 {
1804         struct uf_entry *ufp;
1805         uf_info_t *fip = P_FINFO(curproc);
1806 
1807         UF_ENTER(ufp, fip, fd);
1808         /*
1809          * delfd_port is always done inside the getf/releasef pair.
1810          */
1811         ASSERT(ufp->uf_refcnt >= 1);
1812         if (ufp->uf_portfd == pfd) {
1813                 /* remove first entry */
1814                 ufp->uf_portfd = pfd->pfd_next;
1815         } else {
1816                 pfd->pfd_prev->pfd_next = pfd->pfd_next;
1817                 if (pfd->pfd_next != NULL)
1818                         pfd->pfd_next->pfd_prev = pfd->pfd_prev;
1819         }
1820         UF_EXIT(ufp);
1821 }
1822 
1823 static void
1824 port_close_fd(portfd_t *pfd)
1825 {
1826         portfd_t        *pfdn;
1827 
1828         /*
1829          * At this point, no other thread should access
1830          * the portfd_t list for this fd. The uf_file, uf_portfd
1831          * pointers in the uf_entry_t struct for this fd would
1832          * be set to NULL.
1833          */
1834         for (; pfd != NULL; pfd = pfdn) {
1835                 pfdn = pfd->pfd_next;
1836                 port_close_pfd(pfd);
1837         }
1838 }