Lines Matching defs:fdp
104 static int closefp(struct filedesc *fdp, int fd, struct file *fp,
108 struct filedesc *fdp, int flags);
109 static int fd_first_free(struct filedesc *fdp, int low, int size);
110 static void fdgrowtable(struct filedesc *fdp, int nfd);
111 static void fdgrowtable_exp(struct filedesc *fdp, int nfd);
112 static void fdunused(struct filedesc *fdp, int fd);
113 static void fdused(struct filedesc *fdp, int fd);
154 #define FILEDESC_FOREACH_FDE(fdp, _iterator, _fde) \
155 struct filedesc *_fdp = (fdp); \
160 #define FILEDESC_FOREACH_FP(fdp, _iterator, _fp) \
161 struct filedesc *_fdp = (fdp); \
205 fd_first_free(struct filedesc *fdp, int low, int size)
207 NDSLOTTYPE *map = fdp->fd_map;
230 * Call this variant if fdp can't be modified by anyone else (e.g, during exec).
234 fdlastfile_single(struct filedesc *fdp)
236 NDSLOTTYPE *map = fdp->fd_map;
239 off = NDSLOT(fdp->fd_nfiles - 1);
247 fdlastfile(struct filedesc *fdp)
250 FILEDESC_LOCK_ASSERT(fdp);
251 return (fdlastfile_single(fdp));
255 fdisused(struct filedesc *fdp, int fd)
258 KASSERT(fd >= 0 && fd < fdp->fd_nfiles,
259 ("file descriptor %d out of range (0, %d)", fd, fdp->fd_nfiles));
261 return ((fdp->fd_map[NDSLOT(fd)] & NDBIT(fd)) != 0);
268 fdused_init(struct filedesc *fdp, int fd)
271 KASSERT(!fdisused(fdp, fd), ("fd=%d is already used", fd));
273 fdp->fd_map[NDSLOT(fd)] |= NDBIT(fd);
277 fdused(struct filedesc *fdp, int fd)
280 FILEDESC_XLOCK_ASSERT(fdp);
282 fdused_init(fdp, fd);
283 if (fd == fdp->fd_freefile)
284 fdp->fd_freefile++;
291 fdunused(struct filedesc *fdp, int fd)
294 FILEDESC_XLOCK_ASSERT(fdp);
296 KASSERT(fdisused(fdp, fd), ("fd=%d is already unused", fd));
297 KASSERT(fdp->fd_ofiles[fd].fde_file == NULL,
300 fdp->fd_map[NDSLOT(fd)] &= ~NDBIT(fd);
301 if (fd < fdp->fd_freefile)
302 fdp->fd_freefile = fd;
308 * Avoid some work if fdp is about to be destroyed.
318 fdfree(struct filedesc *fdp, int fd)
322 FILEDESC_XLOCK_ASSERT(fdp);
323 fde = &fdp->fd_ofiles[fd];
332 fdunused(fdp, fd);
486 struct filedesc *fdp;
501 fdp = p->p_fd;
528 FILEDESC_SLOCK(fdp);
529 fde = fdeget_noref(fdp, fd);
535 FILEDESC_SUNLOCK(fdp);
540 FILEDESC_XLOCK(fdp);
541 fde = fdeget_noref(fdp, fd);
547 FILEDESC_XUNLOCK(fdp);
893 FILEDESC_SLOCK(fdp);
894 error = fget_cap_noref(fdp, fd, &cap_fcntl_rights, &fp, NULL);
896 export_file_to_kinfo(fp, fd, NULL, kif, fdp, 0);
897 FILEDESC_SUNLOCK(fdp);
906 FILEDESC_SUNLOCK(fdp);
933 struct filedesc *fdp;
941 fdp = p->p_fd;
964 FILEDESC_XLOCK(fdp);
965 if (fget_noref(fdp, old) == NULL)
970 fdp->fd_ofiles[new].fde_flags |= UF_EXCLOSE;
975 oldfde = &fdp->fd_ofiles[old];
994 if (new >= fdp->fd_nfiles) {
1013 fdgrowtable_exp(fdp, new + 1);
1015 if (!fdisused(fdp, new))
1016 fdused(fdp, new);
1025 oldfde = &fdp->fd_ofiles[old];
1030 newfde = &fdp->fd_ofiles[new];
1057 (void) closefp(fdp, new, delfp, td, true, false);
1058 FILEDESC_UNLOCK_ASSERT(fdp);
1061 FILEDESC_XUNLOCK(fdp);
1290 closefp_impl(struct filedesc *fdp, int fd, struct file *fp, struct thread *td,
1295 FILEDESC_XLOCK_ASSERT(fdp);
1303 if (__predict_false(!TAILQ_EMPTY(&fdp->fd_kqlist)))
1311 FILEDESC_XUNLOCK(fdp);
1331 closefp_hl(struct filedesc *fdp, int fd, struct file *fp, struct thread *td,
1336 FILEDESC_XLOCK_ASSERT(fdp);
1344 fdp->fd_holdleaderscount++;
1350 error = closefp_impl(fdp, fd, fp, td, audit);
1352 FILEDESC_XLOCK(fdp);
1353 fdp->fd_holdleaderscount--;
1354 if (fdp->fd_holdleaderscount == 0 &&
1355 fdp->fd_holdleaderswakeup != 0) {
1356 fdp->fd_holdleaderswakeup = 0;
1357 wakeup(&fdp->fd_holdleaderscount);
1359 FILEDESC_XUNLOCK(fdp);
1365 closefp(struct filedesc *fdp, int fd, struct file *fp, struct thread *td,
1369 FILEDESC_XLOCK_ASSERT(fdp);
1372 return (closefp_hl(fdp, fd, fp, td, holdleaders, audit));
1374 return (closefp_impl(fdp, fd, fp, td, audit));
1397 struct filedesc *fdp;
1400 fdp = td->td_proc->p_fd;
1402 FILEDESC_XLOCK(fdp);
1403 if ((fp = fget_noref(fdp, fd)) == NULL) {
1404 FILEDESC_XUNLOCK(fdp);
1407 fdfree(fdp, fd);
1410 return (closefp(fdp, fd, fp, td, true, true));
1416 struct filedesc *fdp;
1421 fdp = td->td_proc->p_fd;
1422 FILEDESC_XLOCK(fdp);
1423 fdt = atomic_load_ptr(&fdp->fd_files);
1435 FILEDESC_XUNLOCK(fdp);
1442 struct filedesc *fdp;
1447 fdp = td->td_proc->p_fd;
1448 FILEDESC_XLOCK(fdp);
1449 fdt = atomic_load_ptr(&fdp->fd_files);
1461 fdfree(fdp, fd);
1462 (void) closefp(fdp, fd, fp, td, true, true);
1465 FILEDESC_XLOCK(fdp);
1466 fdt = atomic_load_ptr(&fdp->fd_files);
1471 FILEDESC_XUNLOCK(fdp);
1875 fdgrowtable_exp(struct filedesc *fdp, int nfd)
1879 FILEDESC_XLOCK_ASSERT(fdp);
1881 nfd1 = fdp->fd_nfiles * 2;
1884 fdgrowtable(fdp, nfd1);
1891 fdgrowtable(struct filedesc *fdp, int nfd)
1900 KASSERT(fdp->fd_nfiles > 0, ("zero-length file table"));
1903 onfiles = fdp->fd_nfiles;
1904 otable = fdp->fd_files;
1905 omap = fdp->fd_map;
1939 fdp->fd_map = nmap;
1947 atomic_store_rel_ptr((volatile void *)&fdp->fd_files, (uintptr_t)ntable);
1959 * static allocation contained within (struct filedesc0 *)fdp,
1968 if (curproc->p_fd != fdp || FILEDESC_IS_ONLY_USER(fdp)) {
1972 fdp0 = (struct filedesc0 *)fdp;
1993 struct filedesc *fdp = p->p_fd;
1999 FILEDESC_XLOCK_ASSERT(fdp);
2001 if (fdp->fd_freefile > minfd)
2002 minfd = fdp->fd_freefile;
2010 fd = fd_first_free(fdp, minfd, fdp->fd_nfiles);
2013 if (__predict_false(fd >= fdp->fd_nfiles)) {
2026 fdgrowtable_exp(fdp, allocfd);
2033 KASSERT(fd >= 0 && fd < min(maxfd, fdp->fd_nfiles),
2035 KASSERT(!fdisused(fdp, fd),
2037 KASSERT(fdp->fd_ofiles[fd].fde_file == NULL,
2039 fdused(fdp, fd);
2051 struct filedesc *fdp = p->p_fd;
2054 FILEDESC_XLOCK_ASSERT(fdp);
2062 fdunused(fdp, fds[i]);
2153 _finstall(struct filedesc *fdp, struct file *fp, int fd, int flags,
2161 FILEDESC_XLOCK_ASSERT(fdp);
2163 fde = &fdp->fd_ofiles[fd];
2182 struct filedesc *fdp = td->td_proc->p_fd;
2187 FILEDESC_XLOCK(fdp);
2190 _finstall(fdp, fp, *fd, flags, fcaps);
2192 FILEDESC_XUNLOCK(fdp);
2216 * If fdp is not NULL, return with it shared locked.
2288 struct filedesc *fdp;
2291 fdp = atomic_load_ptr(&p->p_fd);
2292 if (fdp != NULL)
2293 refcount_acquire(&fdp->fd_holdcnt);
2294 return (fdp);
2310 fddrop(struct filedesc *fdp)
2313 if (refcount_load(&fdp->fd_holdcnt) > 1) {
2314 if (refcount_release(&fdp->fd_holdcnt) == 0)
2318 FILEDESC_LOCK_DESTROY(fdp);
2319 uma_zfree(filedesc0_zone, fdp);
2348 fdshare(struct filedesc *fdp)
2351 refcount_acquire(&fdp->fd_refcnt);
2352 return (fdp);
2406 fdcopy(struct filedesc *fdp)
2412 MPASS(fdp != NULL);
2415 FILEDESC_SLOCK(fdp);
2417 lastfile = fdlastfile(fdp);
2420 FILEDESC_SUNLOCK(fdp);
2422 FILEDESC_SLOCK(fdp);
2425 newfdp->fd_freefile = fdp->fd_freefile;
2426 FILEDESC_FOREACH_FDE(fdp, i, ofde) {
2429 if (newfdp->fd_freefile == fdp->fd_freefile)
2439 FILEDESC_SUNLOCK(fdp);
2460 * Clear POSIX style locks. This is only used when fdp looses a reference (i.e.
2466 struct filedesc *fdp;
2475 fdp = p->p_fd;
2479 FILEDESC_XLOCK(fdp);
2485 FILEDESC_FOREACH_FP(fdp, i, fp) {
2489 FILEDESC_XUNLOCK(fdp);
2498 FILEDESC_XLOCK(fdp);
2504 if (fdp->fd_holdleaderscount > 0 &&
2510 fdp->fd_holdleaderswakeup = 1;
2511 sx_sleep(&fdp->fd_holdleaderscount,
2512 FILEDESC_LOCK(fdp), PLOCK, "fdlhold", 0);
2521 sx_sleep(fdtol, FILEDESC_LOCK(fdp), PLOCK,
2534 FILEDESC_XUNLOCK(fdp);
2543 fdescfree_fds(struct thread *td, struct filedesc *fdp)
2551 KASSERT(refcount_load(&fdp->fd_refcnt) == 0,
2552 ("%s: fd table %p carries references", __func__, fdp));
2557 if (refcount_load(&fdp->fd_holdcnt) > 1) {
2558 FILEDESC_XLOCK(fdp);
2559 FILEDESC_XUNLOCK(fdp);
2562 FILEDESC_FOREACH_FDE(fdp, i, fde) {
2568 if (NDSLOTS(fdp->fd_nfiles) > NDSLOTS(NDFILE))
2569 free(fdp->fd_map, M_FILEDESC);
2570 if (fdp->fd_nfiles > NDFILE)
2571 free(fdp->fd_files, M_FILEDESC);
2573 fdp0 = (struct filedesc0 *)fdp;
2577 fddrop(fdp);
2584 struct filedesc *fdp;
2587 fdp = p->p_fd;
2588 MPASS(fdp != NULL);
2605 if (refcount_release(&fdp->fd_refcnt) == 0)
2608 fdescfree_fds(td, fdp);
2658 struct filedesc *fdp;
2662 fdp = td->td_proc->p_fd;
2663 KASSERT(refcount_load(&fdp->fd_refcnt) == 1,
2665 MPASS(fdp->fd_nfiles >= 3);
2667 fp = fdp->fd_ofiles[i].fde_file;
2669 FILEDESC_XLOCK(fdp);
2675 fdfree(fdp, i);
2676 FILEDESC_XUNLOCK(fdp);
2692 struct filedesc *fdp = td->td_proc->p_fd;
2694 FILEDESC_XLOCK(fdp);
2695 if (fdp->fd_ofiles[idx].fde_file == fp) {
2696 fdfree(fdp, idx);
2697 FILEDESC_XUNLOCK(fdp);
2700 FILEDESC_XUNLOCK(fdp);
2709 struct filedesc *fdp;
2714 fdp = td->td_proc->p_fd;
2715 KASSERT(refcount_load(&fdp->fd_refcnt) == 1,
2717 FILEDESC_FOREACH_FDE(fdp, i, fde) {
2721 FILEDESC_XLOCK(fdp);
2722 fdfree(fdp, i);
2723 (void) closefp(fdp, i, fp, td, false, false);
2724 FILEDESC_UNLOCK_ASSERT(fdp);
2739 struct filedesc *fdp;
2743 fdp = td->td_proc->p_fd;
2744 KASSERT(refcount_load(&fdp->fd_refcnt) == 1,
2746 MPASS(fdp->fd_nfiles >= 3);
2749 if (fdp->fd_ofiles[i].fde_file != NULL)
2781 struct filedesc *fdp;
2813 fdp = td->td_proc->p_fd;
2814 FILEDESC_XLOCK(fdp);
2822 FILEDESC_XUNLOCK(fdp);
2831 FILEDESC_XLOCK(fdp);
2839 FILEDESC_XUNLOCK(fdp);
2882 fget_cap_noref(struct filedesc *fdp, int fd, cap_rights_t *needrightsp,
2888 FILEDESC_LOCK_ASSERT(fdp);
2891 fde = fdeget_noref(fdp, fd);
2918 struct filedesc *fdp = td->td_proc->p_fd;
2930 if (!filecaps_copy(&fdp->fd_ofiles[fd].fde_caps,
2937 if (!fd_modified(fdp, fd, seq))
2946 FILEDESC_SLOCK(fdp);
2947 error = fget_cap_noref(fdp, fd, needrightsp, fpp, havecapsp);
2950 FILEDESC_SUNLOCK(fdp);
2970 struct filedesc *fdp;
2978 fdp = fdhold(p);
2980 if (fdp == NULL)
2982 FILEDESC_SLOCK(fdp);
2983 if (refcount_load(&fdp->fd_refcnt) != 0) {
2984 fp = fget_noref(fdp, fd);
2994 FILEDESC_SUNLOCK(fdp);
2995 fddrop(fdp);
3005 struct filedesc *fdp;
3019 fdp = curproc->p_fd;
3020 fdt = fdp->fd_files;
3044 fdt = fdp->fd_files;
3072 struct filedesc *fdp;
3080 fdp = curproc->p_fd;
3081 fdt = fdp->fd_files;
3097 fdt = fdp->fd_files;
3188 struct filedesc *fdp;
3196 fdp = td->td_proc->p_fd;
3197 fdt = fdp->fd_files;
3209 fdt = atomic_load_ptr(&fdp->fd_files);
3216 fdt = atomic_load_ptr(&fdp->fd_files);
3220 fdt = atomic_load_ptr(&fdp->fd_files);
3228 fdt = fdp->fd_files;
3244 struct filedesc *fdp;
3248 fdp = td->td_proc->p_fd;
3249 fdt = fdp->fd_files;
3258 fdt = atomic_load_ptr(&fdp->fd_files);
3266 fdt = fdp->fd_files;
3287 struct filedesc *fdp;
3298 fdp = td->td_proc->p_fd;
3299 fdt = fdp->fd_files;
3326 fdt = fdp->fd_files;
3353 fget_only_user(struct filedesc *fdp, int fd, cap_rights_t *needrightsp,
3362 MPASS(FILEDESC_IS_ONLY_USER(fdp));
3365 if (__predict_false(fd >= fdp->fd_nfiles))
3368 fdt = fdp->fd_files;
3383 fget_only_user(struct filedesc *fdp, int fd, cap_rights_t *needrightsp,
3388 MPASS(FILEDESC_IS_ONLY_USER(fdp));
3391 if (__predict_false(fd >= fdp->fd_nfiles))
3394 fp = fdp->fd_ofiles[fd].fde_file;
3483 struct filedesc *fdp;
3488 fdp = td->td_proc->p_fd;
3499 fdrights = *cap_rights(fdp, fd);
3500 if (!fd_modified(fdp, fd, seq))
3536 struct filedesc *fdp = td->td_proc->p_fd;
3547 error = cap_fcntl_check(fdp, fd, needfcntl);
3548 if (!fd_modified(fdp, fd, seq))
3741 dupfdopen(struct thread *td, struct filedesc *fdp, int dfd, int mode,
3757 FILEDESC_XLOCK(fdp);
3758 if ((fp = fget_noref(fdp, dfd)) == NULL) {
3759 FILEDESC_XUNLOCK(fdp);
3765 FILEDESC_XUNLOCK(fdp);
3784 fdunused(fdp, indx);
3785 FILEDESC_XUNLOCK(fdp);
3789 fdunused(fdp, indx);
3790 FILEDESC_XUNLOCK(fdp);
3793 newfde = &fdp->fd_ofiles[indx];
3794 oldfde = &fdp->fd_ofiles[dfd];
3810 newfde = &fdp->fd_ofiles[indx];
3811 oldfde = &fdp->fd_ofiles[dfd];
3818 fdunused(fdp, dfd);
3825 FILEDESC_XUNLOCK(fdp);
3849 chroot_refuse_vdir_fds(struct filedesc *fdp)
3855 FILEDESC_LOCK_ASSERT(fdp);
3857 FILEDESC_FOREACH_FP(fdp, i, fp) {
3994 struct filedesc *fdp;
3998 fdp = td->td_proc->p_fd;
4001 FILEDESC_SLOCK(fdp);
4007 error = chroot_refuse_vdir_fds(fdp);
4008 FILEDESC_SUNLOCK(fdp);
4015 FILEDESC_SUNLOCK(fdp);
4093 struct filedesc *fdp;
4097 fdp = td->td_proc->p_fd;
4100 FILEDESC_SLOCK(fdp);
4103 error = chroot_refuse_vdir_fds(fdp);
4104 FILEDESC_SUNLOCK(fdp);
4276 descrip_check_write_mp(struct filedesc *fdp, struct mount *mp)
4283 FILEDESC_SLOCK(fdp);
4284 FILEDESC_FOREACH_FP(fdp, i, fp) {
4294 FILEDESC_SUNLOCK(fdp);
4299 filedesc_to_leader_alloc(struct filedesc_to_leader *old, struct filedesc *fdp,
4311 FILEDESC_XLOCK(fdp);
4316 FILEDESC_XUNLOCK(fdp);
4325 filedesc_to_leader_share(struct filedesc_to_leader *fdtol, struct filedesc *fdp)
4327 FILEDESC_XLOCK(fdp);
4329 FILEDESC_XUNLOCK(fdp);
4334 filedesc_nfiles(struct filedesc *fdp)
4339 if (fdp == NULL)
4342 FILEDESC_SLOCK(fdp);
4343 map = fdp->fd_map;
4344 off = NDSLOT(fdp->fd_nfiles - 1);
4347 FILEDESC_SUNLOCK(fdp);
4354 struct filedesc *fdp;
4358 fdp = fdhold(p);
4360 res = filedesc_nfiles(fdp);
4361 fddrop(fdp);
4393 struct filedesc *fdp;
4410 fdp = fdhold(p);
4412 if (fdp == NULL)
4415 n += fdp->fd_nfiles;
4416 fddrop(fdp);
4437 fdp = fdhold(p);
4439 if (fdp == NULL)
4441 FILEDESC_SLOCK(fdp);
4442 if (refcount_load(&fdp->fd_refcnt) == 0)
4444 FILEDESC_FOREACH_FP(fdp, n, fp) {
4465 FILEDESC_SUNLOCK(fdp);
4466 fddrop(fdp);
4526 struct kinfo_file *kif, struct filedesc *fdp, int flags)
4547 error = fo_fill_kinfo(fp, kif, fdp);
4581 struct filedesc *fdp;
4613 export_file_to_kinfo(fp, fd, rightsp, &efbuf->kif, efbuf->fdp,
4615 FILEDESC_SUNLOCK(efbuf->fdp);
4617 FILEDESC_SLOCK(efbuf->fdp);
4648 struct filedesc *fdp;
4671 fdp = fdhold(p);
4676 efbuf->fdp = NULL;
4692 if (error != 0 || pdp == NULL || fdp == NULL)
4694 efbuf->fdp = fdp;
4723 FILEDESC_SLOCK(fdp);
4724 if (refcount_load(&fdp->fd_refcnt) == 0)
4726 FILEDESC_FOREACH_FP(fdp, i, fp) {
4728 rights = *cap_rights(fdp, i);
4739 if (error != 0 || refcount_load(&fdp->fd_refcnt) == 0)
4743 FILEDESC_SUNLOCK(fdp);
4745 if (fdp != NULL)
4746 fddrop(fdp);
4845 struct filedesc *fdp;
4861 fdp = fdhold(p);
4862 if (fdp != NULL)
4865 if (fdp == NULL || pdp == NULL) {
4866 if (fdp != NULL)
4867 fddrop(fdp);
4888 FILEDESC_SLOCK(fdp);
4889 if (refcount_load(&fdp->fd_refcnt) == 0)
4891 FILEDESC_FOREACH_FP(fdp, i, fp) {
4892 export_file_to_kinfo(fp, i, NULL, kif, fdp,
4894 FILEDESC_SUNLOCK(fdp);
4897 FILEDESC_SLOCK(fdp);
4898 if (error != 0 || refcount_load(&fdp->fd_refcnt) == 0)
4902 FILEDESC_SUNLOCK(fdp);
4903 fddrop(fdp);
4970 efbuf->fdp = NULL;
5079 struct filedesc *fdp;
5086 fdp = p->p_fd;
5087 if (fdp == NULL)
5089 for (n = 0; n < fdp->fd_nfiles; n++) {
5090 if (fp == fdp->fd_ofiles[n].fde_file)
5131 struct filedesc *fdp;
5141 if ((fdp = p->p_fd) == NULL)
5143 for (n = 0; n < fdp->fd_nfiles; ++n) {
5144 if ((fp = fdp->fd_ofiles[n].fde_file) == NULL)
5264 badfo_fill_kinfo(struct file *fp, struct kinfo_file *kif, struct filedesc *fdp)