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 }