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 (void) VOP_IOCTL(cufp->uf_file->f_vnode, F_ASSOCI_PID, 868 (intptr_t)cp->p_pidp->pid_id, FKIOCTL, kcred, 869 NULL, NULL); 870 } 871 872 if (pufp->uf_file == NULL) { 873 ASSERT(pufp->uf_flag == 0); 874 if (pufp->uf_busy) { 875 /* 876 * Grab locks to appease ASSERTs in fd_reserve 877 */ 878 mutex_enter(&cfip->fi_lock); 879 mutex_enter(&cufp->uf_lock); 880 fd_reserve(cfip, fd, -1); 881 mutex_exit(&cufp->uf_lock); 882 mutex_exit(&cfip->fi_lock); 883 } 884 } 885 } 886 } 887 888 /* 889 * Close all open file descriptors for the current process. 890 * This is only called from exit(), which is single-threaded, 891 * so we don't need any locking. 892 */ 893 void 894 closeall(uf_info_t *fip) 895 { 896 int fd; 897 file_t *fp; 898 uf_entry_t *ufp; 899 900 ufp = fip->fi_list; 901 for (fd = 0; fd < fip->fi_nfiles; fd++, ufp++) { 902 if ((fp = ufp->uf_file) != NULL) { 903 ufp->uf_file = NULL; 904 if (ufp->uf_portfd != NULL) { 905 portfd_t *pfd; 906 /* remove event port association */ 907 pfd = ufp->uf_portfd; 908 ufp->uf_portfd = NULL; 909 port_close_fd(pfd); 910 } 911 ASSERT(ufp->uf_fpollinfo == NULL); 912 (void) closef(fp); 913 } 914 } 915 916 kmem_free(fip->fi_list, fip->fi_nfiles * sizeof (uf_entry_t)); 917 fip->fi_list = NULL; 918 fip->fi_nfiles = 0; 919 while (fip->fi_rlist != NULL) { 920 uf_rlist_t *urp = fip->fi_rlist; 921 fip->fi_rlist = urp->ur_next; 922 kmem_free(urp->ur_list, urp->ur_nfiles * sizeof (uf_entry_t)); 923 kmem_free(urp, sizeof (uf_rlist_t)); 924 } 925 } 926 927 /* 928 * Internal form of close. Decrement reference count on file 929 * structure. Decrement reference count on the vnode following 930 * removal of the referencing file structure. 931 */ 932 int 933 closef(file_t *fp) 934 { 935 vnode_t *vp; 936 int error; 937 int count; 938 int flag; 939 offset_t offset; 940 941 /* 942 * audit close of file (may be exit) 943 */ 944 if (AU_AUDITING()) 945 audit_closef(fp); 946 ASSERT(MUTEX_NOT_HELD(&P_FINFO(curproc)->fi_lock)); 947 948 mutex_enter(&fp->f_tlock); 949 950 ASSERT(fp->f_count > 0); 951 952 count = fp->f_count--; 953 flag = fp->f_flag; 954 offset = fp->f_offset; 955 956 vp = fp->f_vnode; 957 if (vp != NULL) { 958 (void) VOP_IOCTL(vp, F_DASSOC_PID, 959 (intptr_t)(ttoproc(curthread)->p_pidp->pid_id), FKIOCTL, 960 kcred, NULL, NULL); 961 } 962 963 error = VOP_CLOSE(vp, flag, count, offset, fp->f_cred, NULL); 964 965 if (count > 1) { 966 mutex_exit(&fp->f_tlock); 967 return (error); 968 } 969 ASSERT(fp->f_count == 0); 970 mutex_exit(&fp->f_tlock); 971 972 /* 973 * If DTrace has getf() subroutines active, it will set dtrace_closef 974 * to point to code that implements a barrier with respect to probe 975 * context. This must be called before the file_t is freed (and the 976 * vnode that it refers to is released) -- but it must be after the 977 * file_t has been removed from the uf_entry_t. That is, there must 978 * be no way for a racing getf() in probe context to yield the fp that 979 * we're operating upon. 980 */ 981 if (dtrace_closef != NULL) 982 (*dtrace_closef)(); 983 984 VN_RELE(vp); 985 /* 986 * deallocate resources to audit_data 987 */ 988 if (audit_active) 989 audit_unfalloc(fp); 990 crfree(fp->f_cred); 991 kmem_cache_free(file_cache, fp); 992 return (error); 993 } 994 995 /* 996 * This is a combination of ufalloc() and setf(). 997 */ 998 int 999 ufalloc_file(int start, file_t *fp) 1000 { 1001 proc_t *p = curproc; 1002 uf_info_t *fip = P_FINFO(p); 1003 int filelimit; 1004 uf_entry_t *ufp; 1005 int nfiles; 1006 int fd; 1007 1008 /* 1009 * Assertion is to convince the correctness of the following 1010 * assignment for filelimit after casting to int. 1011 */ 1012 ASSERT(p->p_fno_ctl <= INT_MAX); 1013 filelimit = (int)p->p_fno_ctl; 1014 1015 for (;;) { 1016 mutex_enter(&fip->fi_lock); 1017 fd = fd_find(fip, start); 1018 if (fd >= 0 && fd == fip->fi_badfd) { 1019 start = fd + 1; 1020 mutex_exit(&fip->fi_lock); 1021 continue; 1022 } 1023 if ((uint_t)fd < filelimit) 1024 break; 1025 if (fd >= filelimit) { 1026 mutex_exit(&fip->fi_lock); 1027 mutex_enter(&p->p_lock); 1028 (void) rctl_action(rctlproc_legacy[RLIMIT_NOFILE], 1029 p->p_rctls, p, RCA_SAFE); 1030 mutex_exit(&p->p_lock); 1031 return (-1); 1032 } 1033 /* fd_find() returned -1 */ 1034 nfiles = fip->fi_nfiles; 1035 mutex_exit(&fip->fi_lock); 1036 flist_grow(MAX(start, nfiles)); 1037 } 1038 1039 UF_ENTER(ufp, fip, fd); 1040 fd_reserve(fip, fd, 1); 1041 ASSERT(ufp->uf_file == NULL); 1042 ufp->uf_file = fp; 1043 UF_EXIT(ufp); 1044 mutex_exit(&fip->fi_lock); 1045 return (fd); 1046 } 1047 1048 /* 1049 * Allocate a user file descriptor greater than or equal to "start". 1050 */ 1051 int 1052 ufalloc(int start) 1053 { 1054 return (ufalloc_file(start, NULL)); 1055 } 1056 1057 /* 1058 * Check that a future allocation of count fds on proc p has a good 1059 * chance of succeeding. If not, do rctl processing as if we'd failed 1060 * the allocation. 1061 * 1062 * Our caller must guarantee that p cannot disappear underneath us. 1063 */ 1064 int 1065 ufcanalloc(proc_t *p, uint_t count) 1066 { 1067 uf_info_t *fip = P_FINFO(p); 1068 int filelimit; 1069 int current; 1070 1071 if (count == 0) 1072 return (1); 1073 1074 ASSERT(p->p_fno_ctl <= INT_MAX); 1075 filelimit = (int)p->p_fno_ctl; 1076 1077 mutex_enter(&fip->fi_lock); 1078 current = flist_nalloc(fip); /* # of in-use descriptors */ 1079 mutex_exit(&fip->fi_lock); 1080 1081 /* 1082 * If count is a positive integer, the worst that can happen is 1083 * an overflow to a negative value, which is caught by the >= 0 check. 1084 */ 1085 current += count; 1086 if (count <= INT_MAX && current >= 0 && current <= filelimit) 1087 return (1); 1088 1089 mutex_enter(&p->p_lock); 1090 (void) rctl_action(rctlproc_legacy[RLIMIT_NOFILE], 1091 p->p_rctls, p, RCA_SAFE); 1092 mutex_exit(&p->p_lock); 1093 return (0); 1094 } 1095 1096 /* 1097 * Allocate a user file descriptor and a file structure. 1098 * Initialize the descriptor to point at the file structure. 1099 * If fdp is NULL, the user file descriptor will not be allocated. 1100 */ 1101 int 1102 falloc(vnode_t *vp, int flag, file_t **fpp, int *fdp) 1103 { 1104 file_t *fp; 1105 int fd; 1106 1107 if (fdp) { 1108 if ((fd = ufalloc(0)) == -1) 1109 return (EMFILE); 1110 } 1111 fp = kmem_cache_alloc(file_cache, KM_SLEEP); 1112 /* 1113 * Note: falloc returns the fp locked 1114 */ 1115 mutex_enter(&fp->f_tlock); 1116 fp->f_count = 1; 1117 fp->f_flag = (ushort_t)flag; 1118 fp->f_flag2 = (flag & (FSEARCH|FEXEC)) >> 16; 1119 fp->f_vnode = vp; 1120 fp->f_offset = 0; 1121 fp->f_audit_data = 0; 1122 crhold(fp->f_cred = CRED()); 1123 /* 1124 * allocate resources to audit_data 1125 */ 1126 if (audit_active) 1127 audit_falloc(fp); 1128 *fpp = fp; 1129 if (fdp) 1130 *fdp = fd; 1131 return (0); 1132 } 1133 1134 /*ARGSUSED*/ 1135 static int 1136 file_cache_constructor(void *buf, void *cdrarg, int kmflags) 1137 { 1138 file_t *fp = buf; 1139 1140 mutex_init(&fp->f_tlock, NULL, MUTEX_DEFAULT, NULL); 1141 return (0); 1142 } 1143 1144 /*ARGSUSED*/ 1145 static void 1146 file_cache_destructor(void *buf, void *cdrarg) 1147 { 1148 file_t *fp = buf; 1149 1150 mutex_destroy(&fp->f_tlock); 1151 } 1152 1153 void 1154 finit() 1155 { 1156 file_cache = kmem_cache_create("file_cache", sizeof (file_t), 0, 1157 file_cache_constructor, file_cache_destructor, NULL, NULL, NULL, 0); 1158 } 1159 1160 void 1161 unfalloc(file_t *fp) 1162 { 1163 ASSERT(MUTEX_HELD(&fp->f_tlock)); 1164 if (--fp->f_count <= 0) { 1165 /* 1166 * deallocate resources to audit_data 1167 */ 1168 if (audit_active) 1169 audit_unfalloc(fp); 1170 crfree(fp->f_cred); 1171 mutex_exit(&fp->f_tlock); 1172 kmem_cache_free(file_cache, fp); 1173 } else 1174 mutex_exit(&fp->f_tlock); 1175 } 1176 1177 /* 1178 * Given a file descriptor, set the user's 1179 * file pointer to the given parameter. 1180 */ 1181 void 1182 setf(int fd, file_t *fp) 1183 { 1184 uf_info_t *fip = P_FINFO(curproc); 1185 uf_entry_t *ufp; 1186 1187 if (AU_AUDITING()) 1188 audit_setf(fp, fd); 1189 1190 if (fp == NULL) { 1191 mutex_enter(&fip->fi_lock); 1192 UF_ENTER(ufp, fip, fd); 1193 fd_reserve(fip, fd, -1); 1194 mutex_exit(&fip->fi_lock); 1195 } else { 1196 UF_ENTER(ufp, fip, fd); 1197 ASSERT(ufp->uf_busy); 1198 } 1199 ASSERT(ufp->uf_fpollinfo == NULL); 1200 ASSERT(ufp->uf_flag == 0); 1201 ufp->uf_file = fp; 1202 cv_broadcast(&ufp->uf_wanted_cv); 1203 UF_EXIT(ufp); 1204 } 1205 1206 /* 1207 * Given a file descriptor, return the file table flags, plus, 1208 * if this is a socket in asynchronous mode, the FASYNC flag. 1209 * getf() may or may not have been called before calling f_getfl(). 1210 */ 1211 int 1212 f_getfl(int fd, int *flagp) 1213 { 1214 uf_info_t *fip = P_FINFO(curproc); 1215 uf_entry_t *ufp; 1216 file_t *fp; 1217 int error; 1218 1219 if ((uint_t)fd >= fip->fi_nfiles) 1220 error = EBADF; 1221 else { 1222 UF_ENTER(ufp, fip, fd); 1223 if ((fp = ufp->uf_file) == NULL) 1224 error = EBADF; 1225 else { 1226 vnode_t *vp = fp->f_vnode; 1227 int flag = fp->f_flag | (fp->f_flag2 << 16); 1228 1229 /* 1230 * BSD fcntl() FASYNC compatibility. 1231 */ 1232 if (vp->v_type == VSOCK) 1233 flag |= sock_getfasync(vp); 1234 *flagp = flag; 1235 error = 0; 1236 } 1237 UF_EXIT(ufp); 1238 } 1239 1240 return (error); 1241 } 1242 1243 /* 1244 * Given a file descriptor, return the user's file flags. 1245 * Force the FD_CLOEXEC flag for writable self-open /proc files. 1246 * getf() may or may not have been called before calling f_getfd_error(). 1247 */ 1248 int 1249 f_getfd_error(int fd, int *flagp) 1250 { 1251 uf_info_t *fip = P_FINFO(curproc); 1252 uf_entry_t *ufp; 1253 file_t *fp; 1254 int flag; 1255 int error; 1256 1257 if ((uint_t)fd >= fip->fi_nfiles) 1258 error = EBADF; 1259 else { 1260 UF_ENTER(ufp, fip, fd); 1261 if ((fp = ufp->uf_file) == NULL) 1262 error = EBADF; 1263 else { 1264 flag = ufp->uf_flag; 1265 if ((fp->f_flag & FWRITE) && pr_isself(fp->f_vnode)) 1266 flag |= FD_CLOEXEC; 1267 *flagp = flag; 1268 error = 0; 1269 } 1270 UF_EXIT(ufp); 1271 } 1272 1273 return (error); 1274 } 1275 1276 /* 1277 * getf() must have been called before calling f_getfd(). 1278 */ 1279 char 1280 f_getfd(int fd) 1281 { 1282 int flag = 0; 1283 (void) f_getfd_error(fd, &flag); 1284 return ((char)flag); 1285 } 1286 1287 /* 1288 * Given a file descriptor and file flags, set the user's file flags. 1289 * At present, the only valid flag is FD_CLOEXEC. 1290 * getf() may or may not have been called before calling f_setfd_error(). 1291 */ 1292 int 1293 f_setfd_error(int fd, int flags) 1294 { 1295 uf_info_t *fip = P_FINFO(curproc); 1296 uf_entry_t *ufp; 1297 int error; 1298 1299 if ((uint_t)fd >= fip->fi_nfiles) 1300 error = EBADF; 1301 else { 1302 UF_ENTER(ufp, fip, fd); 1303 if (ufp->uf_file == NULL) 1304 error = EBADF; 1305 else { 1306 ufp->uf_flag = flags & FD_CLOEXEC; 1307 error = 0; 1308 } 1309 UF_EXIT(ufp); 1310 } 1311 return (error); 1312 } 1313 1314 void 1315 f_setfd(int fd, char flags) 1316 { 1317 (void) f_setfd_error(fd, flags); 1318 } 1319 1320 #define BADFD_MIN 3 1321 #define BADFD_MAX 255 1322 1323 /* 1324 * Attempt to allocate a file descriptor which is bad and which 1325 * is "poison" to the application. It cannot be closed (except 1326 * on exec), allocated for a different use, etc. 1327 */ 1328 int 1329 f_badfd(int start, int *fdp, int action) 1330 { 1331 int fdr; 1332 int badfd; 1333 uf_info_t *fip = P_FINFO(curproc); 1334 1335 #ifdef _LP64 1336 /* No restrictions on 64 bit _file */ 1337 if (get_udatamodel() != DATAMODEL_ILP32) 1338 return (EINVAL); 1339 #endif 1340 1341 if (start > BADFD_MAX || start < BADFD_MIN) 1342 return (EINVAL); 1343 1344 if (action >= NSIG || action < 0) 1345 return (EINVAL); 1346 1347 mutex_enter(&fip->fi_lock); 1348 badfd = fip->fi_badfd; 1349 mutex_exit(&fip->fi_lock); 1350 1351 if (badfd != -1) 1352 return (EAGAIN); 1353 1354 fdr = ufalloc(start); 1355 1356 if (fdr > BADFD_MAX) { 1357 setf(fdr, NULL); 1358 return (EMFILE); 1359 } 1360 if (fdr < 0) 1361 return (EMFILE); 1362 1363 mutex_enter(&fip->fi_lock); 1364 if (fip->fi_badfd != -1) { 1365 /* Lost race */ 1366 mutex_exit(&fip->fi_lock); 1367 setf(fdr, NULL); 1368 return (EAGAIN); 1369 } 1370 fip->fi_action = action; 1371 fip->fi_badfd = fdr; 1372 mutex_exit(&fip->fi_lock); 1373 setf(fdr, NULL); 1374 1375 *fdp = fdr; 1376 1377 return (0); 1378 } 1379 1380 /* 1381 * Allocate a file descriptor and assign it to the vnode "*vpp", 1382 * performing the usual open protocol upon it and returning the 1383 * file descriptor allocated. It is the responsibility of the 1384 * caller to dispose of "*vpp" if any error occurs. 1385 */ 1386 int 1387 fassign(vnode_t **vpp, int mode, int *fdp) 1388 { 1389 file_t *fp; 1390 int error; 1391 int fd; 1392 1393 if (error = falloc((vnode_t *)NULL, mode, &fp, &fd)) 1394 return (error); 1395 if (error = VOP_OPEN(vpp, mode, fp->f_cred, NULL)) { 1396 setf(fd, NULL); 1397 unfalloc(fp); 1398 return (error); 1399 } 1400 fp->f_vnode = *vpp; 1401 mutex_exit(&fp->f_tlock); 1402 /* 1403 * Fill in the slot falloc reserved. 1404 */ 1405 setf(fd, fp); 1406 *fdp = fd; 1407 return (0); 1408 } 1409 1410 /* 1411 * When a process forks it must increment the f_count of all file pointers 1412 * since there is a new process pointing at them. fcnt_add(fip, 1) does this. 1413 * Since we are called when there is only 1 active lwp we don't need to 1414 * hold fi_lock or any uf_lock. If the fork fails, fork_fail() calls 1415 * fcnt_add(fip, -1) to restore the counts. 1416 */ 1417 void 1418 fcnt_add(uf_info_t *fip, int incr) 1419 { 1420 int i; 1421 uf_entry_t *ufp; 1422 file_t *fp; 1423 1424 ufp = fip->fi_list; 1425 for (i = 0; i < fip->fi_nfiles; i++, ufp++) { 1426 if ((fp = ufp->uf_file) != NULL) { 1427 mutex_enter(&fp->f_tlock); 1428 ASSERT((incr == 1 && fp->f_count >= 1) || 1429 (incr == -1 && fp->f_count >= 2)); 1430 fp->f_count += incr; 1431 mutex_exit(&fp->f_tlock); 1432 } 1433 } 1434 } 1435 1436 /* 1437 * This is called from exec to close all fd's that have the FD_CLOEXEC flag 1438 * set and also to close all self-open for write /proc file descriptors. 1439 */ 1440 void 1441 close_exec(uf_info_t *fip) 1442 { 1443 int fd; 1444 file_t *fp; 1445 fpollinfo_t *fpip; 1446 uf_entry_t *ufp; 1447 portfd_t *pfd; 1448 1449 ufp = fip->fi_list; 1450 for (fd = 0; fd < fip->fi_nfiles; fd++, ufp++) { 1451 if ((fp = ufp->uf_file) != NULL && 1452 ((ufp->uf_flag & FD_CLOEXEC) || 1453 ((fp->f_flag & FWRITE) && pr_isself(fp->f_vnode)))) { 1454 fpip = ufp->uf_fpollinfo; 1455 mutex_enter(&fip->fi_lock); 1456 mutex_enter(&ufp->uf_lock); 1457 fd_reserve(fip, fd, -1); 1458 mutex_exit(&fip->fi_lock); 1459 ufp->uf_file = NULL; 1460 ufp->uf_fpollinfo = NULL; 1461 ufp->uf_flag = 0; 1462 /* 1463 * We may need to cleanup some cached poll states 1464 * in t_pollstate before the fd can be reused. It 1465 * is important that we don't access a stale thread 1466 * structure. We will do the cleanup in two 1467 * phases to avoid deadlock and holding uf_lock for 1468 * too long. In phase 1, hold the uf_lock and call 1469 * pollblockexit() to set state in t_pollstate struct 1470 * so that a thread does not exit on us. In phase 2, 1471 * we drop the uf_lock and call pollcacheclean(). 1472 */ 1473 pfd = ufp->uf_portfd; 1474 ufp->uf_portfd = NULL; 1475 if (fpip != NULL) 1476 pollblockexit(fpip); 1477 mutex_exit(&ufp->uf_lock); 1478 if (fpip != NULL) 1479 pollcacheclean(fpip, fd); 1480 if (pfd) 1481 port_close_fd(pfd); 1482 (void) closef(fp); 1483 } 1484 } 1485 1486 /* Reset bad fd */ 1487 fip->fi_badfd = -1; 1488 fip->fi_action = -1; 1489 } 1490 1491 /* 1492 * Utility function called by most of the *at() system call interfaces. 1493 * 1494 * Generate a starting vnode pointer for an (fd, path) pair where 'fd' 1495 * is an open file descriptor for a directory to be used as the starting 1496 * point for the lookup of the relative pathname 'path' (or, if path is 1497 * NULL, generate a vnode pointer for the direct target of the operation). 1498 * 1499 * If we successfully return a non-NULL startvp, it has been the target 1500 * of VN_HOLD() and the caller must call VN_RELE() on it. 1501 */ 1502 int 1503 fgetstartvp(int fd, char *path, vnode_t **startvpp) 1504 { 1505 vnode_t *startvp; 1506 file_t *startfp; 1507 char startchar; 1508 1509 if (fd == AT_FDCWD && path == NULL) 1510 return (EFAULT); 1511 1512 if (fd == AT_FDCWD) { 1513 /* 1514 * Start from the current working directory. 1515 */ 1516 startvp = NULL; 1517 } else { 1518 if (path == NULL) 1519 startchar = '\0'; 1520 else if (copyin(path, &startchar, sizeof (char))) 1521 return (EFAULT); 1522 1523 if (startchar == '/') { 1524 /* 1525 * 'path' is an absolute pathname. 1526 */ 1527 startvp = NULL; 1528 } else { 1529 /* 1530 * 'path' is a relative pathname or we will 1531 * be applying the operation to 'fd' itself. 1532 */ 1533 if ((startfp = getf(fd)) == NULL) 1534 return (EBADF); 1535 startvp = startfp->f_vnode; 1536 VN_HOLD(startvp); 1537 releasef(fd); 1538 } 1539 } 1540 *startvpp = startvp; 1541 return (0); 1542 } 1543 1544 /* 1545 * Called from fchownat() and fchmodat() to set ownership and mode. 1546 * The contents of *vap must be set before calling here. 1547 */ 1548 int 1549 fsetattrat(int fd, char *path, int flags, struct vattr *vap) 1550 { 1551 vnode_t *startvp; 1552 vnode_t *vp; 1553 int error; 1554 1555 /* 1556 * Since we are never called to set the size of a file, we don't 1557 * need to check for non-blocking locks (via nbl_need_check(vp)). 1558 */ 1559 ASSERT(!(vap->va_mask & AT_SIZE)); 1560 1561 if ((error = fgetstartvp(fd, path, &startvp)) != 0) 1562 return (error); 1563 if (AU_AUDITING() && startvp != NULL) 1564 audit_setfsat_path(1); 1565 1566 /* 1567 * Do lookup for fchownat/fchmodat when path not NULL 1568 */ 1569 if (path != NULL) { 1570 if (error = lookupnameat(path, UIO_USERSPACE, 1571 (flags == AT_SYMLINK_NOFOLLOW) ? 1572 NO_FOLLOW : FOLLOW, 1573 NULLVPP, &vp, startvp)) { 1574 if (startvp != NULL) 1575 VN_RELE(startvp); 1576 return (error); 1577 } 1578 } else { 1579 vp = startvp; 1580 ASSERT(vp); 1581 VN_HOLD(vp); 1582 } 1583 1584 if (vn_is_readonly(vp)) { 1585 error = EROFS; 1586 } else { 1587 error = VOP_SETATTR(vp, vap, 0, CRED(), NULL); 1588 } 1589 1590 if (startvp != NULL) 1591 VN_RELE(startvp); 1592 VN_RELE(vp); 1593 1594 return (error); 1595 } 1596 1597 /* 1598 * Return true if the given vnode is referenced by any 1599 * entry in the current process's file descriptor table. 1600 */ 1601 int 1602 fisopen(vnode_t *vp) 1603 { 1604 int fd; 1605 file_t *fp; 1606 vnode_t *ovp; 1607 uf_info_t *fip = P_FINFO(curproc); 1608 uf_entry_t *ufp; 1609 1610 mutex_enter(&fip->fi_lock); 1611 for (fd = 0; fd < fip->fi_nfiles; fd++) { 1612 UF_ENTER(ufp, fip, fd); 1613 if ((fp = ufp->uf_file) != NULL && 1614 (ovp = fp->f_vnode) != NULL && VN_CMP(vp, ovp)) { 1615 UF_EXIT(ufp); 1616 mutex_exit(&fip->fi_lock); 1617 return (1); 1618 } 1619 UF_EXIT(ufp); 1620 } 1621 mutex_exit(&fip->fi_lock); 1622 return (0); 1623 } 1624 1625 /* 1626 * Return zero if at least one file currently open (by curproc) shouldn't be 1627 * allowed to change zones. 1628 */ 1629 int 1630 files_can_change_zones(void) 1631 { 1632 int fd; 1633 file_t *fp; 1634 uf_info_t *fip = P_FINFO(curproc); 1635 uf_entry_t *ufp; 1636 1637 mutex_enter(&fip->fi_lock); 1638 for (fd = 0; fd < fip->fi_nfiles; fd++) { 1639 UF_ENTER(ufp, fip, fd); 1640 if ((fp = ufp->uf_file) != NULL && 1641 !vn_can_change_zones(fp->f_vnode)) { 1642 UF_EXIT(ufp); 1643 mutex_exit(&fip->fi_lock); 1644 return (0); 1645 } 1646 UF_EXIT(ufp); 1647 } 1648 mutex_exit(&fip->fi_lock); 1649 return (1); 1650 } 1651 1652 #ifdef DEBUG 1653 1654 /* 1655 * The following functions are only used in ASSERT()s elsewhere. 1656 * They do not modify the state of the system. 1657 */ 1658 1659 /* 1660 * Return true (1) if the current thread is in the fpollinfo 1661 * list for this file descriptor, else false (0). 1662 */ 1663 static int 1664 curthread_in_plist(uf_entry_t *ufp) 1665 { 1666 fpollinfo_t *fpip; 1667 1668 ASSERT(MUTEX_HELD(&ufp->uf_lock)); 1669 for (fpip = ufp->uf_fpollinfo; fpip; fpip = fpip->fp_next) 1670 if (fpip->fp_thread == curthread) 1671 return (1); 1672 return (0); 1673 } 1674 1675 /* 1676 * Sanity check to make sure that after lwp_exit(), 1677 * curthread does not appear on any fd's fpollinfo list. 1678 */ 1679 void 1680 checkfpollinfo(void) 1681 { 1682 int fd; 1683 uf_info_t *fip = P_FINFO(curproc); 1684 uf_entry_t *ufp; 1685 1686 mutex_enter(&fip->fi_lock); 1687 for (fd = 0; fd < fip->fi_nfiles; fd++) { 1688 UF_ENTER(ufp, fip, fd); 1689 ASSERT(!curthread_in_plist(ufp)); 1690 UF_EXIT(ufp); 1691 } 1692 mutex_exit(&fip->fi_lock); 1693 } 1694 1695 /* 1696 * Return true (1) if the current thread is in the fpollinfo 1697 * list for this file descriptor, else false (0). 1698 * This is the same as curthread_in_plist(), 1699 * but is called w/o holding uf_lock. 1700 */ 1701 int 1702 infpollinfo(int fd) 1703 { 1704 uf_info_t *fip = P_FINFO(curproc); 1705 uf_entry_t *ufp; 1706 int rc; 1707 1708 UF_ENTER(ufp, fip, fd); 1709 rc = curthread_in_plist(ufp); 1710 UF_EXIT(ufp); 1711 return (rc); 1712 } 1713 1714 #endif /* DEBUG */ 1715 1716 /* 1717 * Add the curthread to fpollinfo list, meaning this fd is currently in the 1718 * thread's poll cache. Each lwp polling this file descriptor should call 1719 * this routine once. 1720 */ 1721 void 1722 addfpollinfo(int fd) 1723 { 1724 struct uf_entry *ufp; 1725 fpollinfo_t *fpip; 1726 uf_info_t *fip = P_FINFO(curproc); 1727 1728 fpip = kmem_zalloc(sizeof (fpollinfo_t), KM_SLEEP); 1729 fpip->fp_thread = curthread; 1730 UF_ENTER(ufp, fip, fd); 1731 /* 1732 * Assert we are not already on the list, that is, that 1733 * this lwp did not call addfpollinfo twice for the same fd. 1734 */ 1735 ASSERT(!curthread_in_plist(ufp)); 1736 /* 1737 * addfpollinfo is always done inside the getf/releasef pair. 1738 */ 1739 ASSERT(ufp->uf_refcnt >= 1); 1740 fpip->fp_next = ufp->uf_fpollinfo; 1741 ufp->uf_fpollinfo = fpip; 1742 UF_EXIT(ufp); 1743 } 1744 1745 /* 1746 * Delete curthread from fpollinfo list if it is there. 1747 */ 1748 void 1749 delfpollinfo(int fd) 1750 { 1751 struct uf_entry *ufp; 1752 struct fpollinfo *fpip; 1753 struct fpollinfo **fpipp; 1754 uf_info_t *fip = P_FINFO(curproc); 1755 1756 UF_ENTER(ufp, fip, fd); 1757 for (fpipp = &ufp->uf_fpollinfo; 1758 (fpip = *fpipp) != NULL; 1759 fpipp = &fpip->fp_next) { 1760 if (fpip->fp_thread == curthread) { 1761 *fpipp = fpip->fp_next; 1762 kmem_free(fpip, sizeof (fpollinfo_t)); 1763 break; 1764 } 1765 } 1766 /* 1767 * Assert that we are not still on the list, that is, that 1768 * this lwp did not call addfpollinfo twice for the same fd. 1769 */ 1770 ASSERT(!curthread_in_plist(ufp)); 1771 UF_EXIT(ufp); 1772 } 1773 1774 /* 1775 * fd is associated with a port. pfd is a pointer to the fd entry in the 1776 * cache of the port. 1777 */ 1778 1779 void 1780 addfd_port(int fd, portfd_t *pfd) 1781 { 1782 struct uf_entry *ufp; 1783 uf_info_t *fip = P_FINFO(curproc); 1784 1785 UF_ENTER(ufp, fip, fd); 1786 /* 1787 * addfd_port is always done inside the getf/releasef pair. 1788 */ 1789 ASSERT(ufp->uf_refcnt >= 1); 1790 if (ufp->uf_portfd == NULL) { 1791 /* first entry */ 1792 ufp->uf_portfd = pfd; 1793 pfd->pfd_next = NULL; 1794 } else { 1795 pfd->pfd_next = ufp->uf_portfd; 1796 ufp->uf_portfd = pfd; 1797 pfd->pfd_next->pfd_prev = pfd; 1798 } 1799 UF_EXIT(ufp); 1800 } 1801 1802 void 1803 delfd_port(int fd, portfd_t *pfd) 1804 { 1805 struct uf_entry *ufp; 1806 uf_info_t *fip = P_FINFO(curproc); 1807 1808 UF_ENTER(ufp, fip, fd); 1809 /* 1810 * delfd_port is always done inside the getf/releasef pair. 1811 */ 1812 ASSERT(ufp->uf_refcnt >= 1); 1813 if (ufp->uf_portfd == pfd) { 1814 /* remove first entry */ 1815 ufp->uf_portfd = pfd->pfd_next; 1816 } else { 1817 pfd->pfd_prev->pfd_next = pfd->pfd_next; 1818 if (pfd->pfd_next != NULL) 1819 pfd->pfd_next->pfd_prev = pfd->pfd_prev; 1820 } 1821 UF_EXIT(ufp); 1822 } 1823 1824 static void 1825 port_close_fd(portfd_t *pfd) 1826 { 1827 portfd_t *pfdn; 1828 1829 /* 1830 * At this point, no other thread should access 1831 * the portfd_t list for this fd. The uf_file, uf_portfd 1832 * pointers in the uf_entry_t struct for this fd would 1833 * be set to NULL. 1834 */ 1835 for (; pfd != NULL; pfd = pfdn) { 1836 pfdn = pfd->pfd_next; 1837 port_close_pfd(pfd); 1838 } 1839 }