sys/kern/kern_descrip.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-3-Clause
   3  *
   4  * Copyright (c) 1982, 1986, 1989, 1991, 1993
   5  *      The Regents of the University of California.  All rights reserved.
   6  * (c) UNIX System Laboratories, Inc.
   7  * All or some portions of this file are derived from material licensed
   8  * to the University of California by American Telephone and Telegraph
   9  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
  10  * the permission of UNIX System Laboratories, Inc.
  11  *
  12  * Redistribution and use in source and binary forms, with or without
  13  * modification, are permitted provided that the following conditions
  14  * are met:
  15  * 1. Redistributions of source code must retain the above copyright
  16  *    notice, this list of conditions and the following disclaimer.
  17  * 2. Redistributions in binary form must reproduce the above copyright
  18  *    notice, this list of conditions and the following disclaimer in the
  19  *    documentation and/or other materials provided with the distribution.
  20  * 3. Neither the name of the University nor the names of its contributors
  21  *    may be used to endorse or promote products derived from this software
  22  *    without specific prior written permission.
  23  *
  24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  34  * SUCH DAMAGE.
  35  *
  36  *      @(#)kern_descrip.c      8.6 (Berkeley) 4/19/94
  37  */
  38
  39 #include <sys/cdefs.h>
  40 __FBSDID("$FreeBSD$");
  41
  42 #include "opt_capsicum.h"
  43 #include "opt_ddb.h"
  44 #include "opt_ktrace.h"
  45
  46 #include <sys/param.h>
  47 #include <sys/systm.h>
  48
  49 #include <sys/capsicum.h>
  50 #include <sys/conf.h>
  51 #include <sys/fcntl.h>
  52 #include <sys/file.h>
  53 #include <sys/filedesc.h>
  54 #include <sys/filio.h>
  55 #include <sys/jail.h>
  56 #include <sys/kernel.h>
  57 #include <sys/limits.h>
  58 #include <sys/lock.h>
  59 #include <sys/malloc.h>
  60 #include <sys/mount.h>
  61 #include <sys/mutex.h>
  62 #include <sys/namei.h>
  63 #include <sys/selinfo.h>
  64 #include <sys/priv.h>
  65 #include <sys/proc.h>
  66 #include <sys/protosw.h>
  67 #include <sys/racct.h>
  68 #include <sys/resourcevar.h>
  69 #include <sys/sbuf.h>
  70 #include <sys/signalvar.h>
  71 #include <sys/kdb.h>
  72 #include <sys/stat.h>
  73 #include <sys/sx.h>
  74 #include <sys/syscallsubr.h>
  75 #include <sys/sysctl.h>
  76 #include <sys/sysproto.h>
  77 #include <sys/unistd.h>
  78 #include <sys/user.h>
  79 #include <sys/vnode.h>
  80 #ifdef KTRACE
  81 #include <sys/ktrace.h>
  82 #endif
  83
  84 #include <net/vnet.h>
  85
  86 #include <security/audit/audit.h>
  87
  88 #include <vm/uma.h>
  89 #include <vm/vm.h>
  90
  91 #include <ddb/ddb.h>
  92
  93 static MALLOC_DEFINE(M_FILEDESC, "filedesc", "Open file descriptor table");
  94 static MALLOC_DEFINE(M_FILEDESC_TO_LEADER, "filedesc_to_leader",
  95     "file desc to leader structures");
  96 static MALLOC_DEFINE(M_SIGIO, "sigio", "sigio structures");
  97 MALLOC_DEFINE(M_FILECAPS, "filecaps", "descriptor capabilities");
  98
  99 MALLOC_DECLARE(M_FADVISE);
 100
 101 static __read_mostly uma_zone_t file_zone;
 102 static __read_mostly uma_zone_t filedesc0_zone;
 103
 104 static int      closefp(struct filedesc *fdp, int fd, struct file *fp,
 105                     struct thread *td, int holdleaders);
 106 static int      fd_first_free(struct filedesc *fdp, int low, int size);
 107 static int      fd_last_used(struct filedesc *fdp, int size);
 108 static void     fdgrowtable(struct filedesc *fdp, int nfd);
 109 static void     fdgrowtable_exp(struct filedesc *fdp, int nfd);
 110 static void     fdunused(struct filedesc *fdp, int fd);
 111 static void     fdused(struct filedesc *fdp, int fd);
 112 static int      getmaxfd(struct thread *td);
 113 static u_long   *filecaps_copy_prep(const struct filecaps *src);
 114 static void     filecaps_copy_finish(const struct filecaps *src,
 115                     struct filecaps *dst, u_long *ioctls);
 116 static u_long   *filecaps_free_prep(struct filecaps *fcaps);
 117 static void     filecaps_free_finish(u_long *ioctls);
 118
 119 /*
 120  * Each process has:
 121  *
 122  * - An array of open file descriptors (fd_ofiles)
 123  * - An array of file flags (fd_ofileflags)
 124  * - A bitmap recording which descriptors are in use (fd_map)
 125  *
 126  * A process starts out with NDFILE descriptors.  The value of NDFILE has
 127  * been selected based the historical limit of 20 open files, and an
 128  * assumption that the majority of processes, especially short-lived
 129  * processes like shells, will never need more.
 130  *
 131  * If this initial allocation is exhausted, a larger descriptor table and
 132  * map are allocated dynamically, and the pointers in the process's struct
 133  * filedesc are updated to point to those.  This is repeated every time
 134  * the process runs out of file descriptors (provided it hasn't hit its
 135  * resource limit).
 136  *
 137  * Since threads may hold references to individual descriptor table
 138  * entries, the tables are never freed.  Instead, they are placed on a
 139  * linked list and freed only when the struct filedesc is released.
 140  */
 141 #define NDFILE          20
 142 #define NDSLOTSIZE      sizeof(NDSLOTTYPE)
 143 #define NDENTRIES       (NDSLOTSIZE * __CHAR_BIT)
 144 #define NDSLOT(x)       ((x) / NDENTRIES)
 145 #define NDBIT(x)        ((NDSLOTTYPE)1 << ((x) % NDENTRIES))
 146 #define NDSLOTS(x)      (((x) + NDENTRIES - 1) / NDENTRIES)
 147
 148 /*
 149  * SLIST entry used to keep track of ofiles which must be reclaimed when
 150  * the process exits.
 151  */
 152 struct freetable {
 153         struct fdescenttbl *ft_table;
 154         SLIST_ENTRY(freetable) ft_next;
 155 };
 156
 157 /*
 158  * Initial allocation: a filedesc structure + the head of SLIST used to
 159  * keep track of old ofiles + enough space for NDFILE descriptors.
 160  */
 161
 162 struct fdescenttbl0 {
 163         int     fdt_nfiles;
 164         struct  filedescent fdt_ofiles[NDFILE];
 165 };
 166
 167 struct filedesc0 {
 168         struct filedesc fd_fd;
 169         SLIST_HEAD(, freetable) fd_free;
 170         struct  fdescenttbl0 fd_dfiles;
 171         NDSLOTTYPE fd_dmap[NDSLOTS(NDFILE)];
 172 };
 173
 174 /*
 175  * Descriptor management.
 176  */
 177 static int __exclusive_cache_line openfiles; /* actual number of open files */
 178 struct mtx sigio_lock;          /* mtx to protect pointers to sigio */
 179 void __read_mostly (*mq_fdclose)(struct thread *td, int fd, struct file *fp);
 180
 181 /*
 182  * If low >= size, just return low. Otherwise find the first zero bit in the
 183  * given bitmap, starting at low and not exceeding size - 1. Return size if
 184  * not found.
 185  */
 186 static int
 187 fd_first_free(struct filedesc *fdp, int low, int size)
 188 {
 189         NDSLOTTYPE *map = fdp->fd_map;
 190         NDSLOTTYPE mask;
 191         int off, maxoff;
 192
 193         if (low >= size)
 194                 return (low);
 195
 196         off = NDSLOT(low);
 197         if (low % NDENTRIES) {
 198                 mask = ~(~(NDSLOTTYPE)0 >> (NDENTRIES - (low % NDENTRIES)));
 199                 if ((mask &= ~map[off]) != 0UL)
 200                         return (off * NDENTRIES + ffsl(mask) - 1);
 201                 ++off;
 202         }
 203         for (maxoff = NDSLOTS(size); off < maxoff; ++off)
 204                 if (map[off] != ~0UL)
 205                         return (off * NDENTRIES + ffsl(~map[off]) - 1);
 206         return (size);
 207 }
 208
 209 /*
 210  * Find the highest non-zero bit in the given bitmap, starting at 0 and
 211  * not exceeding size - 1. Return -1 if not found.
 212  */
 213 static int
 214 fd_last_used(struct filedesc *fdp, int size)
 215 {
 216         NDSLOTTYPE *map = fdp->fd_map;
 217         NDSLOTTYPE mask;
 218         int off, minoff;
 219
 220         off = NDSLOT(size);
 221         if (size % NDENTRIES) {
 222                 mask = ~(~(NDSLOTTYPE)0 << (size % NDENTRIES));
 223                 if ((mask &= map[off]) != 0)
 224                         return (off * NDENTRIES + flsl(mask) - 1);
 225                 --off;
 226         }
 227         for (minoff = NDSLOT(0); off >= minoff; --off)
 228                 if (map[off] != 0)
 229                         return (off * NDENTRIES + flsl(map[off]) - 1);
 230         return (-1);
 231 }
 232
 233 static int
 234 fdisused(struct filedesc *fdp, int fd)
 235 {
 236
 237         KASSERT(fd >= 0 && fd < fdp->fd_nfiles,
 238             ("file descriptor %d out of range (0, %d)", fd, fdp->fd_nfiles));
 239
 240         return ((fdp->fd_map[NDSLOT(fd)] & NDBIT(fd)) != 0);
 241 }
 242
 243 /*
 244  * Mark a file descriptor as used.
 245  */
 246 static void
 247 fdused_init(struct filedesc *fdp, int fd)
 248 {
 249
 250         KASSERT(!fdisused(fdp, fd), ("fd=%d is already used", fd));
 251
 252         fdp->fd_map[NDSLOT(fd)] |= NDBIT(fd);
 253 }
 254
 255 static void
 256 fdused(struct filedesc *fdp, int fd)
 257 {
 258
 259         FILEDESC_XLOCK_ASSERT(fdp);
 260
 261         fdused_init(fdp, fd);
 262         if (fd > fdp->fd_lastfile)
 263                 fdp->fd_lastfile = fd;
 264         if (fd == fdp->fd_freefile)
 265                 fdp->fd_freefile++;
 266 }
 267
 268 /*
 269  * Mark a file descriptor as unused.
 270  */
 271 static void
 272 fdunused(struct filedesc *fdp, int fd)
 273 {
 274
 275         FILEDESC_XLOCK_ASSERT(fdp);
 276
 277         KASSERT(fdisused(fdp, fd), ("fd=%d is already unused", fd));
 278         KASSERT(fdp->fd_ofiles[fd].fde_file == NULL,
 279             ("fd=%d is still in use", fd));
 280
 281         fdp->fd_map[NDSLOT(fd)] &= ~NDBIT(fd);
 282         if (fd < fdp->fd_freefile)
 283                 fdp->fd_freefile = fd;
 284         if (fd == fdp->fd_lastfile)
 285                 fdp->fd_lastfile = fd_last_used(fdp, fd);
 286 }
 287
 288 /*
 289  * Free a file descriptor.
 290  *
 291  * Avoid some work if fdp is about to be destroyed.
 292  */
 293 static inline void
 294 fdefree_last(struct filedescent *fde)
 295 {
 296
 297         filecaps_free(&fde->fde_caps);
 298 }
 299
 300 static inline void
 301 fdfree(struct filedesc *fdp, int fd)
 302 {
 303         struct filedescent *fde;
 304
 305         fde = &fdp->fd_ofiles[fd];
 306 #ifdef CAPABILITIES
 307         seqc_write_begin(&fde->fde_seqc);
 308 #endif
 309         fde->fde_file = NULL;
 310 #ifdef CAPABILITIES
 311         seqc_write_end(&fde->fde_seqc);
 312 #endif
 313         fdefree_last(fde);
 314         fdunused(fdp, fd);
 315 }
 316
 317 void
 318 pwd_ensure_dirs(void)
 319 {
 320         struct filedesc *fdp;
 321
 322         fdp = curproc->p_fd;
 323         FILEDESC_XLOCK(fdp);
 324         if (fdp->fd_cdir == NULL) {
 325                 fdp->fd_cdir = rootvnode;
 326                 vrefact(rootvnode);
 327         }
 328         if (fdp->fd_rdir == NULL) {
 329                 fdp->fd_rdir = rootvnode;
 330                 vrefact(rootvnode);
 331         }
 332         FILEDESC_XUNLOCK(fdp);
 333 }
 334
 335 /*
 336  * System calls on descriptors.
 337  */
 338 #ifndef _SYS_SYSPROTO_H_
 339 struct getdtablesize_args {
 340         int     dummy;
 341 };
 342 #endif
 343 /* ARGSUSED */
 344 int
 345 sys_getdtablesize(struct thread *td, struct getdtablesize_args *uap)
 346 {
 347 #ifdef  RACCT
 348         uint64_t lim;
 349 #endif
 350
 351         td->td_retval[0] = getmaxfd(td);
 352 #ifdef  RACCT
 353         PROC_LOCK(td->td_proc);
 354         lim = racct_get_limit(td->td_proc, RACCT_NOFILE);
 355         PROC_UNLOCK(td->td_proc);
 356         if (lim < td->td_retval[0])
 357                 td->td_retval[0] = lim;
 358 #endif
 359         return (0);
 360 }
 361
 362 /*
 363  * Duplicate a file descriptor to a particular value.
 364  *
 365  * Note: keep in mind that a potential race condition exists when closing
 366  * descriptors from a shared descriptor table (via rfork).
 367  */
 368 #ifndef _SYS_SYSPROTO_H_
 369 struct dup2_args {
 370         u_int   from;
 371         u_int   to;
 372 };
 373 #endif
 374 /* ARGSUSED */
 375 int
 376 sys_dup2(struct thread *td, struct dup2_args *uap)
 377 {
 378
 379         return (kern_dup(td, FDDUP_FIXED, 0, (int)uap->from, (int)uap->to));
 380 }
 381
 382 /*
 383  * Duplicate a file descriptor.
 384  */
 385 #ifndef _SYS_SYSPROTO_H_
 386 struct dup_args {
 387         u_int   fd;
 388 };
 389 #endif
 390 /* ARGSUSED */
 391 int
 392 sys_dup(struct thread *td, struct dup_args *uap)
 393 {
 394
 395         return (kern_dup(td, FDDUP_NORMAL, 0, (int)uap->fd, 0));
 396 }
 397
 398 /*
 399  * The file control system call.
 400  */
 401 #ifndef _SYS_SYSPROTO_H_
 402 struct fcntl_args {
 403         int     fd;
 404         int     cmd;
 405         long    arg;
 406 };
 407 #endif
 408 /* ARGSUSED */
 409 int
 410 sys_fcntl(struct thread *td, struct fcntl_args *uap)
 411 {
 412
 413         return (kern_fcntl_freebsd(td, uap->fd, uap->cmd, uap->arg));
 414 }
 415
 416 int
 417 kern_fcntl_freebsd(struct thread *td, int fd, int cmd, long arg)
 418 {
 419         struct flock fl;
 420         struct __oflock ofl;
 421         intptr_t arg1;
 422         int error, newcmd;
 423
 424         error = 0;
 425         newcmd = cmd;
 426         switch (cmd) {
 427         case F_OGETLK:
 428         case F_OSETLK:
 429         case F_OSETLKW:
 430                 /*
 431                  * Convert old flock structure to new.
 432                  */
 433                 error = copyin((void *)(intptr_t)arg, &ofl, sizeof(ofl));
 434                 fl.l_start = ofl.l_start;
 435                 fl.l_len = ofl.l_len;
 436                 fl.l_pid = ofl.l_pid;
 437                 fl.l_type = ofl.l_type;
 438                 fl.l_whence = ofl.l_whence;
 439                 fl.l_sysid = 0;
 440
 441                 switch (cmd) {
 442                 case F_OGETLK:
 443                         newcmd = F_GETLK;
 444                         break;
 445                 case F_OSETLK:
 446                         newcmd = F_SETLK;
 447                         break;
 448                 case F_OSETLKW:
 449                         newcmd = F_SETLKW;
 450                         break;
 451                 }
 452                 arg1 = (intptr_t)&fl;
 453                 break;
 454         case F_GETLK:
 455         case F_SETLK:
 456         case F_SETLKW:
 457         case F_SETLK_REMOTE:
 458                 error = copyin((void *)(intptr_t)arg, &fl, sizeof(fl));
 459                 arg1 = (intptr_t)&fl;
 460                 break;
 461         default:
 462                 arg1 = arg;
 463                 break;
 464         }
 465         if (error)
 466                 return (error);
 467         error = kern_fcntl(td, fd, newcmd, arg1);
 468         if (error)
 469                 return (error);
 470         if (cmd == F_OGETLK) {
 471                 ofl.l_start = fl.l_start;
 472                 ofl.l_len = fl.l_len;
 473                 ofl.l_pid = fl.l_pid;
 474                 ofl.l_type = fl.l_type;
 475                 ofl.l_whence = fl.l_whence;
 476                 error = copyout(&ofl, (void *)(intptr_t)arg, sizeof(ofl));
 477         } else if (cmd == F_GETLK) {
 478                 error = copyout(&fl, (void *)(intptr_t)arg, sizeof(fl));
 479         }
 480         return (error);
 481 }
 482
 483 int
 484 kern_fcntl(struct thread *td, int fd, int cmd, intptr_t arg)
 485 {
 486         struct filedesc *fdp;
 487         struct flock *flp;
 488         struct file *fp, *fp2;
 489         struct filedescent *fde;
 490         struct proc *p;
 491         struct vnode *vp;
 492         int error, flg, seals, tmp;
 493         uint64_t bsize;
 494         off_t foffset;
 495
 496         error = 0;
 497         flg = F_POSIX;
 498         p = td->td_proc;
 499         fdp = p->p_fd;
 500
 501         AUDIT_ARG_FD(cmd);
 502         AUDIT_ARG_CMD(cmd);
 503         switch (cmd) {
 504         case F_DUPFD:
 505                 tmp = arg;
 506                 error = kern_dup(td, FDDUP_FCNTL, 0, fd, tmp);
 507                 break;
 508
 509         case F_DUPFD_CLOEXEC:
 510                 tmp = arg;
 511                 error = kern_dup(td, FDDUP_FCNTL, FDDUP_FLAG_CLOEXEC, fd, tmp);
 512                 break;
 513
 514         case F_DUP2FD:
 515                 tmp = arg;
 516                 error = kern_dup(td, FDDUP_FIXED, 0, fd, tmp);
 517                 break;
 518
 519         case F_DUP2FD_CLOEXEC:
 520                 tmp = arg;
 521                 error = kern_dup(td, FDDUP_FIXED, FDDUP_FLAG_CLOEXEC, fd, tmp);
 522                 break;
 523
 524         case F_GETFD:
 525                 error = EBADF;
 526                 FILEDESC_SLOCK(fdp);
 527                 fde = fdeget_locked(fdp, fd);
 528                 if (fde != NULL) {
 529                         td->td_retval[0] =
 530                             (fde->fde_flags & UF_EXCLOSE) ? FD_CLOEXEC : 0;
 531                         error = 0;
 532                 }
 533                 FILEDESC_SUNLOCK(fdp);
 534                 break;
 535
 536         case F_SETFD:
 537                 error = EBADF;
 538                 FILEDESC_XLOCK(fdp);
 539                 fde = fdeget_locked(fdp, fd);
 540                 if (fde != NULL) {
 541                         fde->fde_flags = (fde->fde_flags & ~UF_EXCLOSE) |
 542                             (arg & FD_CLOEXEC ? UF_EXCLOSE : 0);
 543                         error = 0;
 544                 }
 545                 FILEDESC_XUNLOCK(fdp);
 546                 break;
 547
 548         case F_GETFL:
 549                 error = fget_fcntl(td, fd, &cap_fcntl_rights, F_GETFL, &fp);
 550                 if (error != 0)
 551                         break;
 552                 td->td_retval[0] = OFLAGS(fp->f_flag);
 553                 fdrop(fp, td);
 554                 break;
 555
 556         case F_SETFL:
 557                 error = fget_fcntl(td, fd, &cap_fcntl_rights, F_SETFL, &fp);
 558                 if (error != 0)
 559                         break;
 560                 do {
 561                         tmp = flg = fp->f_flag;
 562                         tmp &= ~FCNTLFLAGS;
 563                         tmp |= FFLAGS(arg & ~O_ACCMODE) & FCNTLFLAGS;
 564                 } while(atomic_cmpset_int(&fp->f_flag, flg, tmp) == 0);
 565                 tmp = fp->f_flag & FNONBLOCK;
 566                 error = fo_ioctl(fp, FIONBIO, &tmp, td->td_ucred, td);
 567                 if (error != 0) {
 568                         fdrop(fp, td);
 569                         break;
 570                 }
 571                 tmp = fp->f_flag & FASYNC;
 572                 error = fo_ioctl(fp, FIOASYNC, &tmp, td->td_ucred, td);
 573                 if (error == 0) {
 574                         fdrop(fp, td);
 575                         break;
 576                 }
 577                 atomic_clear_int(&fp->f_flag, FNONBLOCK);
 578                 tmp = 0;
 579                 (void)fo_ioctl(fp, FIONBIO, &tmp, td->td_ucred, td);
 580                 fdrop(fp, td);
 581                 break;
 582
 583         case F_GETOWN:
 584                 error = fget_fcntl(td, fd, &cap_fcntl_rights, F_GETOWN, &fp);
 585                 if (error != 0)
 586                         break;
 587                 error = fo_ioctl(fp, FIOGETOWN, &tmp, td->td_ucred, td);
 588                 if (error == 0)
 589                         td->td_retval[0] = tmp;
 590                 fdrop(fp, td);
 591                 break;
 592
 593         case F_SETOWN:
 594                 error = fget_fcntl(td, fd, &cap_fcntl_rights, F_SETOWN, &fp);
 595                 if (error != 0)
 596                         break;
 597                 tmp = arg;
 598                 error = fo_ioctl(fp, FIOSETOWN, &tmp, td->td_ucred, td);
 599                 fdrop(fp, td);
 600                 break;
 601
 602         case F_SETLK_REMOTE:
 603                 error = priv_check(td, PRIV_NFS_LOCKD);
 604                 if (error != 0)
 605                         return (error);
 606                 flg = F_REMOTE;
 607                 goto do_setlk;
 608
 609         case F_SETLKW:
 610                 flg |= F_WAIT;
 611                 /* FALLTHROUGH F_SETLK */
 612
 613         case F_SETLK:
 614         do_setlk:
 615                 flp = (struct flock *)arg;
 616                 if ((flg & F_REMOTE) != 0 && flp->l_sysid == 0) {
 617                         error = EINVAL;
 618                         break;
 619                 }
 620
 621                 error = fget_unlocked(fdp, fd, &cap_flock_rights, &fp, NULL);
 622                 if (error != 0)
 623                         break;
 624                 if (fp->f_type != DTYPE_VNODE) {
 625                         error = EBADF;
 626                         fdrop(fp, td);
 627                         break;
 628                 }
 629
 630                 if (flp->l_whence == SEEK_CUR) {
 631                         foffset = foffset_get(fp);
 632                         if (foffset < 0 ||
 633                             (flp->l_start > 0 &&
 634                              foffset > OFF_MAX - flp->l_start)) {
 635                                 error = EOVERFLOW;
 636                                 fdrop(fp, td);
 637                                 break;
 638                         }
 639                         flp->l_start += foffset;
 640                 }
 641
 642                 vp = fp->f_vnode;
 643                 switch (flp->l_type) {
 644                 case F_RDLCK:
 645                         if ((fp->f_flag & FREAD) == 0) {
 646                                 error = EBADF;
 647                                 break;
 648                         }
 649                         if ((p->p_leader->p_flag & P_ADVLOCK) == 0) {
 650                                 PROC_LOCK(p->p_leader);
 651                                 p->p_leader->p_flag |= P_ADVLOCK;
 652                                 PROC_UNLOCK(p->p_leader);
 653                         }
 654                         error = VOP_ADVLOCK(vp, (caddr_t)p->p_leader, F_SETLK,
 655                             flp, flg);
 656                         break;
 657                 case F_WRLCK:
 658                         if ((fp->f_flag & FWRITE) == 0) {
 659                                 error = EBADF;
 660                                 break;
 661                         }
 662                         if ((p->p_leader->p_flag & P_ADVLOCK) == 0) {
 663                                 PROC_LOCK(p->p_leader);
 664                                 p->p_leader->p_flag |= P_ADVLOCK;
 665                                 PROC_UNLOCK(p->p_leader);
 666                         }
 667                         error = VOP_ADVLOCK(vp, (caddr_t)p->p_leader, F_SETLK,
 668                             flp, flg);
 669                         break;
 670                 case F_UNLCK:
 671                         error = VOP_ADVLOCK(vp, (caddr_t)p->p_leader, F_UNLCK,
 672                             flp, flg);
 673                         break;
 674                 case F_UNLCKSYS:
 675                         if (flg != F_REMOTE) {
 676                                 error = EINVAL;
 677                                 break;
 678                         }
 679                         error = VOP_ADVLOCK(vp, (caddr_t)p->p_leader,
 680                             F_UNLCKSYS, flp, flg);
 681                         break;
 682                 default:
 683                         error = EINVAL;
 684                         break;
 685                 }
 686                 if (error != 0 || flp->l_type == F_UNLCK ||
 687                     flp->l_type == F_UNLCKSYS) {
 688                         fdrop(fp, td);
 689                         break;
 690                 }
 691
 692                 /*
 693                  * Check for a race with close.
 694                  *
 695                  * The vnode is now advisory locked (or unlocked, but this case
 696                  * is not really important) as the caller requested.
 697                  * We had to drop the filedesc lock, so we need to recheck if
 698                  * the descriptor is still valid, because if it was closed
 699                  * in the meantime we need to remove advisory lock from the
 700                  * vnode - close on any descriptor leading to an advisory
 701                  * locked vnode, removes that lock.
 702                  * We will return 0 on purpose in that case, as the result of
 703                  * successful advisory lock might have been externally visible
 704                  * already. This is fine - effectively we pretend to the caller
 705                  * that the closing thread was a bit slower and that the
 706                  * advisory lock succeeded before the close.
 707                  */
 708                 error = fget_unlocked(fdp, fd, &cap_no_rights, &fp2, NULL);
 709                 if (error != 0) {
 710                         fdrop(fp, td);
 711                         break;
 712                 }
 713                 if (fp != fp2) {
 714                         flp->l_whence = SEEK_SET;
 715                         flp->l_start = 0;
 716                         flp->l_len = 0;
 717                         flp->l_type = F_UNLCK;
 718                         (void) VOP_ADVLOCK(vp, (caddr_t)p->p_leader,
 719                             F_UNLCK, flp, F_POSIX);
 720                 }
 721                 fdrop(fp, td);
 722                 fdrop(fp2, td);
 723                 break;
 724
 725         case F_GETLK:
 726                 error = fget_unlocked(fdp, fd, &cap_flock_rights, &fp, NULL);
 727                 if (error != 0)
 728                         break;
 729                 if (fp->f_type != DTYPE_VNODE) {
 730                         error = EBADF;
 731                         fdrop(fp, td);
 732                         break;
 733                 }
 734                 flp = (struct flock *)arg;
 735                 if (flp->l_type != F_RDLCK && flp->l_type != F_WRLCK &&
 736                     flp->l_type != F_UNLCK) {
 737                         error = EINVAL;
 738                         fdrop(fp, td);
 739                         break;
 740                 }
 741                 if (flp->l_whence == SEEK_CUR) {
 742                         foffset = foffset_get(fp);
 743                         if ((flp->l_start > 0 &&
 744                             foffset > OFF_MAX - flp->l_start) ||
 745                             (flp->l_start < 0 &&
 746                             foffset < OFF_MIN - flp->l_start)) {
 747                                 error = EOVERFLOW;
 748                                 fdrop(fp, td);
 749                                 break;
 750                         }
 751                         flp->l_start += foffset;
 752                 }
 753                 vp = fp->f_vnode;
 754                 error = VOP_ADVLOCK(vp, (caddr_t)p->p_leader, F_GETLK, flp,
 755                     F_POSIX);
 756                 fdrop(fp, td);
 757                 break;
 758
 759         case F_ADD_SEALS:
 760                 error = fget_unlocked(fdp, fd, &cap_no_rights, &fp, NULL);
 761                 if (error != 0)
 762                         break;
 763                 error = fo_add_seals(fp, arg);
 764                 fdrop(fp, td);
 765                 break;
 766
 767         case F_GET_SEALS:
 768                 error = fget_unlocked(fdp, fd, &cap_no_rights, &fp, NULL);
 769                 if (error != 0)
 770                         break;
 771                 if (fo_get_seals(fp, &seals) == 0)
 772                         td->td_retval[0] = seals;
 773                 else
 774                         error = EINVAL;
 775                 fdrop(fp, td);
 776                 break;
 777
 778         case F_RDAHEAD:
 779                 arg = arg ? 128 * 1024: 0;
 780                 /* FALLTHROUGH */
 781         case F_READAHEAD:
 782                 error = fget_unlocked(fdp, fd, &cap_no_rights, &fp, NULL);
 783                 if (error != 0)
 784                         break;
 785                 if (fp->f_type != DTYPE_VNODE) {
 786                         fdrop(fp, td);
 787                         error = EBADF;
 788                         break;
 789                 }
 790                 vp = fp->f_vnode;
 791                 if (vp->v_type != VREG) {
 792                         fdrop(fp, td);
 793                         error = ENOTTY;
 794                         break;
 795                 }
 796
 797                 /*
 798                  * Exclusive lock synchronizes against f_seqcount reads and
 799                  * writes in sequential_heuristic().
 800                  */
 801                 error = vn_lock(vp, LK_EXCLUSIVE);
 802                 if (error != 0) {
 803                         fdrop(fp, td);
 804                         break;
 805                 }
 806                 if (arg >= 0) {
 807                         bsize = fp->f_vnode->v_mount->mnt_stat.f_iosize;
 808                         arg = MIN(arg, INT_MAX - bsize + 1);
 809                         fp->f_seqcount = MIN(IO_SEQMAX,
 810                             (arg + bsize - 1) / bsize);
 811                         atomic_set_int(&fp->f_flag, FRDAHEAD);
 812                 } else {
 813                         atomic_clear_int(&fp->f_flag, FRDAHEAD);
 814                 }
 815                 VOP_UNLOCK(vp);
 816                 fdrop(fp, td);
 817                 break;
 818
 819         default:
 820                 error = EINVAL;
 821                 break;
 822         }
 823         return (error);
 824 }
 825
 826 static int
 827 getmaxfd(struct thread *td)
 828 {
 829
 830         return (min((int)lim_cur(td, RLIMIT_NOFILE), maxfilesperproc));
 831 }
 832
 833 /*
 834  * Common code for dup, dup2, fcntl(F_DUPFD) and fcntl(F_DUP2FD).
 835  */
 836 int
 837 kern_dup(struct thread *td, u_int mode, int flags, int old, int new)
 838 {
 839         struct filedesc *fdp;
 840         struct filedescent *oldfde, *newfde;
 841         struct proc *p;
 842         struct file *delfp;
 843         u_long *oioctls, *nioctls;
 844         int error, maxfd;
 845
 846         p = td->td_proc;
 847         fdp = p->p_fd;
 848         oioctls = NULL;
 849
 850         MPASS((flags & ~(FDDUP_FLAG_CLOEXEC)) == 0);
 851         MPASS(mode < FDDUP_LASTMODE);
 852
 853         AUDIT_ARG_FD(old);
 854         /* XXXRW: if (flags & FDDUP_FIXED) AUDIT_ARG_FD2(new); */
 855
 856         /*
 857          * Verify we have a valid descriptor to dup from and possibly to
 858          * dup to. Unlike dup() and dup2(), fcntl()'s F_DUPFD should
 859          * return EINVAL when the new descriptor is out of bounds.
 860          */
 861         if (old < 0)
 862                 return (EBADF);
 863         if (new < 0)
 864                 return (mode == FDDUP_FCNTL ? EINVAL : EBADF);
 865         maxfd = getmaxfd(td);
 866         if (new >= maxfd)
 867                 return (mode == FDDUP_FCNTL ? EINVAL : EBADF);
 868
 869         error = EBADF;
 870         FILEDESC_XLOCK(fdp);
 871         if (fget_locked(fdp, old) == NULL)
 872                 goto unlock;
 873         if ((mode == FDDUP_FIXED || mode == FDDUP_MUSTREPLACE) && old == new) {
 874                 td->td_retval[0] = new;
 875                 if (flags & FDDUP_FLAG_CLOEXEC)
 876                         fdp->fd_ofiles[new].fde_flags |= UF_EXCLOSE;
 877                 error = 0;
 878                 goto unlock;
 879         }
 880
 881         oldfde = &fdp->fd_ofiles[old];
 882         if (!fhold(oldfde->fde_file))
 883                 goto unlock;
 884
 885         /*
 886          * If the caller specified a file descriptor, make sure the file
 887          * table is large enough to hold it, and grab it.  Otherwise, just
 888          * allocate a new descriptor the usual way.
 889          */
 890         switch (mode) {
 891         case FDDUP_NORMAL:
 892         case FDDUP_FCNTL:
 893                 if ((error = fdalloc(td, new, &new)) != 0) {
 894                         fdrop(oldfde->fde_file, td);
 895                         goto unlock;
 896                 }
 897                 break;
 898         case FDDUP_MUSTREPLACE:
 899                 /* Target file descriptor must exist. */
 900                 if (fget_locked(fdp, new) == NULL) {
 901                         fdrop(oldfde->fde_file, td);
 902                         goto unlock;
 903                 }
 904                 break;
 905         case FDDUP_FIXED:
 906                 if (new >= fdp->fd_nfiles) {
 907                         /*
 908                          * The resource limits are here instead of e.g.
 909                          * fdalloc(), because the file descriptor table may be
 910                          * shared between processes, so we can't really use
 911                          * racct_add()/racct_sub().  Instead of counting the
 912                          * number of actually allocated descriptors, just put
 913                          * the limit on the size of the file descriptor table.
 914                          */
 915 #ifdef RACCT
 916                         if (RACCT_ENABLED()) {
 917                                 error = racct_set_unlocked(p, RACCT_NOFILE, new + 1);
 918                                 if (error != 0) {
 919                                         error = EMFILE;
 920                                         fdrop(oldfde->fde_file, td);
 921                                         goto unlock;
 922                                 }
 923                         }
 924 #endif
 925                         fdgrowtable_exp(fdp, new + 1);
 926                 }
 927                 if (!fdisused(fdp, new))
 928                         fdused(fdp, new);
 929                 break;
 930         default:
 931                 KASSERT(0, ("%s unsupported mode %d", __func__, mode));
 932         }
 933
 934         KASSERT(old != new, ("new fd is same as old"));
 935
 936         newfde = &fdp->fd_ofiles[new];
 937         delfp = newfde->fde_file;
 938
 939         oioctls = filecaps_free_prep(&newfde->fde_caps);
 940         nioctls = filecaps_copy_prep(&oldfde->fde_caps);
 941
 942         /*
 943          * Duplicate the source descriptor.
 944          */
 945 #ifdef CAPABILITIES
 946         seqc_write_begin(&newfde->fde_seqc);
 947 #endif
 948         memcpy(newfde, oldfde, fde_change_size);
 949         filecaps_copy_finish(&oldfde->fde_caps, &newfde->fde_caps,
 950             nioctls);
 951         if ((flags & FDDUP_FLAG_CLOEXEC) != 0)
 952                 newfde->fde_flags = oldfde->fde_flags | UF_EXCLOSE;
 953         else
 954                 newfde->fde_flags = oldfde->fde_flags & ~UF_EXCLOSE;
 955 #ifdef CAPABILITIES
 956         seqc_write_end(&newfde->fde_seqc);
 957 #endif
 958         td->td_retval[0] = new;
 959
 960         error = 0;
 961
 962         if (delfp != NULL) {
 963                 (void) closefp(fdp, new, delfp, td, 1);
 964                 FILEDESC_UNLOCK_ASSERT(fdp);
 965         } else {
 966 unlock:
 967                 FILEDESC_XUNLOCK(fdp);
 968         }
 969
 970         filecaps_free_finish(oioctls);
 971         return (error);
 972 }
 973
 974 /*
 975  * If sigio is on the list associated with a process or process group,
 976  * disable signalling from the device, remove sigio from the list and
 977  * free sigio.
 978  */
 979 void
 980 funsetown(struct sigio **sigiop)
 981 {
 982         struct sigio *sigio;
 983
 984         if (*sigiop == NULL)
 985                 return;
 986         SIGIO_LOCK();
 987         sigio = *sigiop;
 988         if (sigio == NULL) {
 989                 SIGIO_UNLOCK();
 990                 return;
 991         }
 992         *(sigio->sio_myref) = NULL;
 993         if ((sigio)->sio_pgid < 0) {
 994                 struct pgrp *pg = (sigio)->sio_pgrp;
 995                 PGRP_LOCK(pg);
 996                 SLIST_REMOVE(&sigio->sio_pgrp->pg_sigiolst, sigio,
 997                             sigio, sio_pgsigio);
 998                 PGRP_UNLOCK(pg);
 999         } else {
1000                 struct proc *p = (sigio)->sio_proc;
1001                 PROC_LOCK(p);
1002                 SLIST_REMOVE(&sigio->sio_proc->p_sigiolst, sigio,
1003                             sigio, sio_pgsigio);
1004                 PROC_UNLOCK(p);
1005         }
1006         SIGIO_UNLOCK();
1007         crfree(sigio->sio_ucred);
1008         free(sigio, M_SIGIO);
1009 }
1010
1011 /*
1012  * Free a list of sigio structures.
1013  * We only need to lock the SIGIO_LOCK because we have made ourselves
1014  * inaccessible to callers of fsetown and therefore do not need to lock
1015  * the proc or pgrp struct for the list manipulation.
1016  */
1017 void
1018 funsetownlst(struct sigiolst *sigiolst)
1019 {
1020         struct proc *p;
1021         struct pgrp *pg;
1022         struct sigio *sigio;
1023
1024         sigio = SLIST_FIRST(sigiolst);
1025         if (sigio == NULL)
1026                 return;
1027         p = NULL;
1028         pg = NULL;
1029
1030         /*
1031          * Every entry of the list should belong
1032          * to a single proc or pgrp.
1033          */
1034         if (sigio->sio_pgid < 0) {
1035                 pg = sigio->sio_pgrp;
1036                 PGRP_LOCK_ASSERT(pg, MA_NOTOWNED);
1037         } else /* if (sigio->sio_pgid > 0) */ {
1038                 p = sigio->sio_proc;
1039                 PROC_LOCK_ASSERT(p, MA_NOTOWNED);
1040         }
1041
1042         SIGIO_LOCK();
1043         while ((sigio = SLIST_FIRST(sigiolst)) != NULL) {
1044                 *(sigio->sio_myref) = NULL;
1045                 if (pg != NULL) {
1046                         KASSERT(sigio->sio_pgid < 0,
1047                             ("Proc sigio in pgrp sigio list"));
1048                         KASSERT(sigio->sio_pgrp == pg,
1049                             ("Bogus pgrp in sigio list"));
1050                         PGRP_LOCK(pg);
1051                         SLIST_REMOVE(&pg->pg_sigiolst, sigio, sigio,
1052                             sio_pgsigio);
1053                         PGRP_UNLOCK(pg);
1054                 } else /* if (p != NULL) */ {
1055                         KASSERT(sigio->sio_pgid > 0,
1056                             ("Pgrp sigio in proc sigio list"));
1057                         KASSERT(sigio->sio_proc == p,
1058                             ("Bogus proc in sigio list"));
1059                         PROC_LOCK(p);
1060                         SLIST_REMOVE(&p->p_sigiolst, sigio, sigio,
1061                             sio_pgsigio);
1062                         PROC_UNLOCK(p);
1063                 }
1064                 SIGIO_UNLOCK();
1065                 crfree(sigio->sio_ucred);
1066                 free(sigio, M_SIGIO);
1067                 SIGIO_LOCK();
1068         }
1069         SIGIO_UNLOCK();
1070 }
1071
1072 /*
1073  * This is common code for FIOSETOWN ioctl called by fcntl(fd, F_SETOWN, arg).
1074  *
1075  * After permission checking, add a sigio structure to the sigio list for
1076  * the process or process group.
1077  */
1078 int
1079 fsetown(pid_t pgid, struct sigio **sigiop)
1080 {
1081         struct proc *proc;
1082         struct pgrp *pgrp;
1083         struct sigio *sigio;
1084         int ret;
1085
1086         if (pgid == 0) {
1087                 funsetown(sigiop);
1088                 return (0);
1089         }
1090
1091         ret = 0;
1092
1093         /* Allocate and fill in the new sigio out of locks. */
1094         sigio = malloc(sizeof(struct sigio), M_SIGIO, M_WAITOK);
1095         sigio->sio_pgid = pgid;
1096         sigio->sio_ucred = crhold(curthread->td_ucred);
1097         sigio->sio_myref = sigiop;
1098
1099         sx_slock(&proctree_lock);
1100         if (pgid > 0) {
1101                 proc = pfind(pgid);
1102                 if (proc == NULL) {
1103                         ret = ESRCH;
1104                         goto fail;
1105                 }
1106
1107                 /*
1108                  * Policy - Don't allow a process to FSETOWN a process
1109                  * in another session.
1110                  *
1111                  * Remove this test to allow maximum flexibility or
1112                  * restrict FSETOWN to the current process or process
1113                  * group for maximum safety.
1114                  */
1115                 PROC_UNLOCK(proc);
1116                 if (proc->p_session != curthread->td_proc->p_session) {
1117                         ret = EPERM;
1118                         goto fail;
1119                 }
1120
1121                 pgrp = NULL;
1122         } else /* if (pgid < 0) */ {
1123                 pgrp = pgfind(-pgid);
1124                 if (pgrp == NULL) {
1125                         ret = ESRCH;
1126                         goto fail;
1127                 }
1128                 PGRP_UNLOCK(pgrp);
1129
1130                 /*
1131                  * Policy - Don't allow a process to FSETOWN a process
1132                  * in another session.
1133                  *
1134                  * Remove this test to allow maximum flexibility or
1135                  * restrict FSETOWN to the current process or process
1136                  * group for maximum safety.
1137                  */
1138                 if (pgrp->pg_session != curthread->td_proc->p_session) {
1139                         ret = EPERM;
1140                         goto fail;
1141                 }
1142
1143                 proc = NULL;
1144         }
1145         funsetown(sigiop);
1146         if (pgid > 0) {
1147                 PROC_LOCK(proc);
1148                 /*
1149                  * Since funsetownlst() is called without the proctree
1150                  * locked, we need to check for P_WEXIT.
1151                  * XXX: is ESRCH correct?
1152                  */
1153                 if ((proc->p_flag & P_WEXIT) != 0) {
1154                         PROC_UNLOCK(proc);
1155                         ret = ESRCH;
1156                         goto fail;
1157                 }
1158                 SLIST_INSERT_HEAD(&proc->p_sigiolst, sigio, sio_pgsigio);
1159                 sigio->sio_proc = proc;
1160                 PROC_UNLOCK(proc);
1161         } else {
1162                 PGRP_LOCK(pgrp);
1163                 SLIST_INSERT_HEAD(&pgrp->pg_sigiolst, sigio, sio_pgsigio);
1164                 sigio->sio_pgrp = pgrp;
1165                 PGRP_UNLOCK(pgrp);
1166         }
1167         sx_sunlock(&proctree_lock);
1168         SIGIO_LOCK();
1169         *sigiop = sigio;
1170         SIGIO_UNLOCK();
1171         return (0);
1172
1173 fail:
1174         sx_sunlock(&proctree_lock);
1175         crfree(sigio->sio_ucred);
1176         free(sigio, M_SIGIO);
1177         return (ret);
1178 }
1179
1180 /*
1181  * This is common code for FIOGETOWN ioctl called by fcntl(fd, F_GETOWN, arg).
1182  */
1183 pid_t
1184 fgetown(struct sigio **sigiop)
1185 {
1186         pid_t pgid;
1187
1188         SIGIO_LOCK();
1189         pgid = (*sigiop != NULL) ? (*sigiop)->sio_pgid : 0;
1190         SIGIO_UNLOCK();
1191         return (pgid);
1192 }
1193
1194 /*
1195  * Function drops the filedesc lock on return.
1196  */
1197 static int
1198 closefp(struct filedesc *fdp, int fd, struct file *fp, struct thread *td,
1199     int holdleaders)
1200 {
1201         int error;
1202
1203         FILEDESC_XLOCK_ASSERT(fdp);
1204
1205         if (holdleaders) {
1206                 if (td->td_proc->p_fdtol != NULL) {
1207                         /*
1208                          * Ask fdfree() to sleep to ensure that all relevant
1209                          * process leaders can be traversed in closef().
1210                          */
1211                         fdp->fd_holdleaderscount++;
1212                 } else {
1213                         holdleaders = 0;
1214                 }
1215         }
1216
1217         /*
1218          * We now hold the fp reference that used to be owned by the
1219          * descriptor array.  We have to unlock the FILEDESC *AFTER*
1220          * knote_fdclose to prevent a race of the fd getting opened, a knote
1221          * added, and deleteing a knote for the new fd.
1222          */
1223         if (__predict_false(!TAILQ_EMPTY(&fdp->fd_kqlist)))
1224                 knote_fdclose(td, fd);
1225
1226         /*
1227          * We need to notify mqueue if the object is of type mqueue.
1228          */
1229         if (__predict_false(fp->f_type == DTYPE_MQUEUE))
1230                 mq_fdclose(td, fd, fp);
1231         FILEDESC_XUNLOCK(fdp);
1232
1233         error = closef(fp, td);
1234         if (holdleaders) {
1235                 FILEDESC_XLOCK(fdp);
1236                 fdp->fd_holdleaderscount--;
1237                 if (fdp->fd_holdleaderscount == 0 &&
1238                     fdp->fd_holdleaderswakeup != 0) {
1239                         fdp->fd_holdleaderswakeup = 0;
1240                         wakeup(&fdp->fd_holdleaderscount);
1241                 }
1242                 FILEDESC_XUNLOCK(fdp);
1243         }
1244         return (error);
1245 }
1246
1247 /*
1248  * Close a file descriptor.
1249  */
1250 #ifndef _SYS_SYSPROTO_H_
1251 struct close_args {
1252         int     fd;
1253 };
1254 #endif
1255 /* ARGSUSED */
1256 int
1257 sys_close(struct thread *td, struct close_args *uap)
1258 {
1259
1260         return (kern_close(td, uap->fd));
1261 }
1262
1263 int
1264 kern_close(struct thread *td, int fd)
1265 {
1266         struct filedesc *fdp;
1267         struct file *fp;
1268
1269         fdp = td->td_proc->p_fd;
1270
1271         AUDIT_SYSCLOSE(td, fd);
1272
1273         FILEDESC_XLOCK(fdp);
1274         if ((fp = fget_locked(fdp, fd)) == NULL) {
1275                 FILEDESC_XUNLOCK(fdp);
1276                 return (EBADF);
1277         }
1278         fdfree(fdp, fd);
1279
1280         /* closefp() drops the FILEDESC lock for us. */
1281         return (closefp(fdp, fd, fp, td, 1));
1282 }
1283
1284 /*
1285  * Close open file descriptors.
1286  */
1287 #ifndef _SYS_SYSPROTO_H_
1288 struct closefrom_args {
1289         int     lowfd;
1290 };
1291 #endif
1292 /* ARGSUSED */
1293 int
1294 sys_closefrom(struct thread *td, struct closefrom_args *uap)
1295 {
1296         struct filedesc *fdp;
1297         int fd;
1298
1299         fdp = td->td_proc->p_fd;
1300         AUDIT_ARG_FD(uap->lowfd);
1301
1302         /*
1303          * Treat negative starting file descriptor values identical to
1304          * closefrom(0) which closes all files.
1305          */
1306         if (uap->lowfd < 0)
1307                 uap->lowfd = 0;
1308         FILEDESC_SLOCK(fdp);
1309         for (fd = uap->lowfd; fd <= fdp->fd_lastfile; fd++) {
1310                 if (fdp->fd_ofiles[fd].fde_file != NULL) {
1311                         FILEDESC_SUNLOCK(fdp);
1312                         (void)kern_close(td, fd);
1313                         FILEDESC_SLOCK(fdp);
1314                 }
1315         }
1316         FILEDESC_SUNLOCK(fdp);
1317         return (0);
1318 }
1319
1320 #if defined(COMPAT_43)
1321 /*
1322  * Return status information about a file descriptor.
1323  */
1324 #ifndef _SYS_SYSPROTO_H_
1325 struct ofstat_args {
1326         int     fd;
1327         struct  ostat *sb;
1328 };
1329 #endif
1330 /* ARGSUSED */
1331 int
1332 ofstat(struct thread *td, struct ofstat_args *uap)
1333 {
1334         struct ostat oub;
1335         struct stat ub;
1336         int error;
1337
1338         error = kern_fstat(td, uap->fd, &ub);
1339         if (error == 0) {
1340                 cvtstat(&ub, &oub);
1341                 error = copyout(&oub, uap->sb, sizeof(oub));
1342         }
1343         return (error);
1344 }
1345 #endif /* COMPAT_43 */
1346
1347 #if defined(COMPAT_FREEBSD11)
1348 int
1349 freebsd11_fstat(struct thread *td, struct freebsd11_fstat_args *uap)
1350 {
1351         struct stat sb;
1352         struct freebsd11_stat osb;
1353         int error;
1354
1355         error = kern_fstat(td, uap->fd, &sb);
1356         if (error != 0)
1357                 return (error);
1358         error = freebsd11_cvtstat(&sb, &osb);
1359         if (error == 0)
1360                 error = copyout(&osb, uap->sb, sizeof(osb));
1361         return (error);
1362 }
1363 #endif  /* COMPAT_FREEBSD11 */
1364
1365 /*
1366  * Return status information about a file descriptor.
1367  */
1368 #ifndef _SYS_SYSPROTO_H_
1369 struct fstat_args {
1370         int     fd;
1371         struct  stat *sb;
1372 };
1373 #endif
1374 /* ARGSUSED */
1375 int
1376 sys_fstat(struct thread *td, struct fstat_args *uap)
1377 {
1378         struct stat ub;
1379         int error;
1380
1381         error = kern_fstat(td, uap->fd, &ub);
1382         if (error == 0)
1383                 error = copyout(&ub, uap->sb, sizeof(ub));
1384         return (error);
1385 }
1386
1387 int
1388 kern_fstat(struct thread *td, int fd, struct stat *sbp)
1389 {
1390         struct file *fp;
1391         int error;
1392
1393         AUDIT_ARG_FD(fd);
1394
1395         error = fget(td, fd, &cap_fstat_rights, &fp);
1396         if (error != 0)
1397                 return (error);
1398
1399         AUDIT_ARG_FILE(td->td_proc, fp);
1400
1401         error = fo_stat(fp, sbp, td->td_ucred, td);
1402         fdrop(fp, td);
1403 #ifdef __STAT_TIME_T_EXT
1404         if (error == 0) {
1405                 sbp->st_atim_ext = 0;
1406                 sbp->st_mtim_ext = 0;
1407                 sbp->st_ctim_ext = 0;
1408                 sbp->st_btim_ext = 0;
1409         }
1410 #endif
1411 #ifdef KTRACE
1412         if (error == 0 && KTRPOINT(td, KTR_STRUCT))
1413                 ktrstat(sbp);
1414 #endif
1415         return (error);
1416 }
1417
1418 #if defined(COMPAT_FREEBSD11)
1419 /*
1420  * Return status information about a file descriptor.
1421  */
1422 #ifndef _SYS_SYSPROTO_H_
1423 struct freebsd11_nfstat_args {
1424         int     fd;
1425         struct  nstat *sb;
1426 };
1427 #endif
1428 /* ARGSUSED */
1429 int
1430 freebsd11_nfstat(struct thread *td, struct freebsd11_nfstat_args *uap)
1431 {
1432         struct nstat nub;
1433         struct stat ub;
1434         int error;
1435
1436         error = kern_fstat(td, uap->fd, &ub);
1437         if (error == 0) {
1438                 freebsd11_cvtnstat(&ub, &nub);
1439                 error = copyout(&nub, uap->sb, sizeof(nub));
1440         }
1441         return (error);
1442 }
1443 #endif /* COMPAT_FREEBSD11 */
1444
1445 /*
1446  * Return pathconf information about a file descriptor.
1447  */
1448 #ifndef _SYS_SYSPROTO_H_
1449 struct fpathconf_args {
1450         int     fd;
1451         int     name;
1452 };
1453 #endif
1454 /* ARGSUSED */
1455 int
1456 sys_fpathconf(struct thread *td, struct fpathconf_args *uap)
1457 {
1458         long value;
1459         int error;
1460
1461         error = kern_fpathconf(td, uap->fd, uap->name, &value);
1462         if (error == 0)
1463                 td->td_retval[0] = value;
1464         return (error);
1465 }
1466
1467 int
1468 kern_fpathconf(struct thread *td, int fd, int name, long *valuep)
1469 {
1470         struct file *fp;
1471         struct vnode *vp;
1472         int error;
1473
1474         error = fget(td, fd, &cap_fpathconf_rights, &fp);
1475         if (error != 0)
1476                 return (error);
1477
1478         if (name == _PC_ASYNC_IO) {
1479                 *valuep = _POSIX_ASYNCHRONOUS_IO;
1480                 goto out;
1481         }
1482         vp = fp->f_vnode;
1483         if (vp != NULL) {
1484                 vn_lock(vp, LK_SHARED | LK_RETRY);
1485                 error = VOP_PATHCONF(vp, name, valuep);
1486                 VOP_UNLOCK(vp);
1487         } else if (fp->f_type == DTYPE_PIPE || fp->f_type == DTYPE_SOCKET) {
1488                 if (name != _PC_PIPE_BUF) {
1489                         error = EINVAL;
1490                 } else {
1491                         *valuep = PIPE_BUF;
1492                         error = 0;
1493                 }
1494         } else {
1495                 error = EOPNOTSUPP;
1496         }
1497 out:
1498         fdrop(fp, td);
1499         return (error);
1500 }
1501
1502 /*
1503  * Copy filecaps structure allocating memory for ioctls array if needed.
1504  *
1505  * The last parameter indicates whether the fdtable is locked. If it is not and
1506  * ioctls are encountered, copying fails and the caller must lock the table.
1507  *
1508  * Note that if the table was not locked, the caller has to check the relevant
1509  * sequence counter to determine whether the operation was successful.
1510  */
1511 bool
1512 filecaps_copy(const struct filecaps *src, struct filecaps *dst, bool locked)
1513 {
1514         size_t size;
1515
1516         if (src->fc_ioctls != NULL && !locked)
1517                 return (false);
1518         memcpy(dst, src, sizeof(*src));
1519         if (src->fc_ioctls == NULL)
1520                 return (true);
1521
1522         KASSERT(src->fc_nioctls > 0,
1523             ("fc_ioctls != NULL, but fc_nioctls=%hd", src->fc_nioctls));
1524
1525         size = sizeof(src->fc_ioctls[0]) * src->fc_nioctls;
1526         dst->fc_ioctls = malloc(size, M_FILECAPS, M_WAITOK);
1527         memcpy(dst->fc_ioctls, src->fc_ioctls, size);
1528         return (true);
1529 }
1530
1531 static u_long *
1532 filecaps_copy_prep(const struct filecaps *src)
1533 {
1534         u_long *ioctls;
1535         size_t size;
1536
1537         if (__predict_true(src->fc_ioctls == NULL))
1538                 return (NULL);
1539
1540         KASSERT(src->fc_nioctls > 0,
1541             ("fc_ioctls != NULL, but fc_nioctls=%hd", src->fc_nioctls));
1542
1543         size = sizeof(src->fc_ioctls[0]) * src->fc_nioctls;
1544         ioctls = malloc(size, M_FILECAPS, M_WAITOK);
1545         return (ioctls);
1546 }
1547
1548 static void
1549 filecaps_copy_finish(const struct filecaps *src, struct filecaps *dst,
1550     u_long *ioctls)
1551 {
1552         size_t size;
1553
1554         *dst = *src;
1555         if (__predict_true(src->fc_ioctls == NULL)) {
1556                 MPASS(ioctls == NULL);
1557                 return;
1558         }
1559
1560         size = sizeof(src->fc_ioctls[0]) * src->fc_nioctls;
1561         dst->fc_ioctls = ioctls;
1562         bcopy(src->fc_ioctls, dst->fc_ioctls, size);
1563 }
1564
1565 /*
1566  * Move filecaps structure to the new place and clear the old place.
1567  */
1568 void
1569 filecaps_move(struct filecaps *src, struct filecaps *dst)
1570 {
1571
1572         *dst = *src;
1573         bzero(src, sizeof(*src));
1574 }
1575
1576 /*
1577  * Fill the given filecaps structure with full rights.
1578  */
1579 static void
1580 filecaps_fill(struct filecaps *fcaps)
1581 {
1582
1583         CAP_ALL(&fcaps->fc_rights);
1584         fcaps->fc_ioctls = NULL;
1585         fcaps->fc_nioctls = -1;
1586         fcaps->fc_fcntls = CAP_FCNTL_ALL;
1587 }
1588
1589 /*
1590  * Free memory allocated within filecaps structure.
1591  */
1592 void
1593 filecaps_free(struct filecaps *fcaps)
1594 {
1595
1596         free(fcaps->fc_ioctls, M_FILECAPS);
1597         bzero(fcaps, sizeof(*fcaps));
1598 }
1599
1600 static u_long *
1601 filecaps_free_prep(struct filecaps *fcaps)
1602 {
1603         u_long *ioctls;
1604
1605         ioctls = fcaps->fc_ioctls;
1606         bzero(fcaps, sizeof(*fcaps));
1607         return (ioctls);
1608 }
1609
1610 static void
1611 filecaps_free_finish(u_long *ioctls)
1612 {
1613
1614         free(ioctls, M_FILECAPS);
1615 }
1616
1617 /*
1618  * Validate the given filecaps structure.
1619  */
1620 static void
1621 filecaps_validate(const struct filecaps *fcaps, const char *func)
1622 {
1623
1624         KASSERT(cap_rights_is_valid(&fcaps->fc_rights),
1625             ("%s: invalid rights", func));
1626         KASSERT((fcaps->fc_fcntls & ~CAP_FCNTL_ALL) == 0,
1627             ("%s: invalid fcntls", func));
1628         KASSERT(fcaps->fc_fcntls == 0 ||
1629             cap_rights_is_set(&fcaps->fc_rights, CAP_FCNTL),
1630             ("%s: fcntls without CAP_FCNTL", func));
1631         KASSERT(fcaps->fc_ioctls != NULL ? fcaps->fc_nioctls > 0 :
1632             (fcaps->fc_nioctls == -1 || fcaps->fc_nioctls == 0),
1633             ("%s: invalid ioctls", func));
1634         KASSERT(fcaps->fc_nioctls == 0 ||
1635             cap_rights_is_set(&fcaps->fc_rights, CAP_IOCTL),
1636             ("%s: ioctls without CAP_IOCTL", func));
1637 }
1638
1639 static void
1640 fdgrowtable_exp(struct filedesc *fdp, int nfd)
1641 {
1642         int nfd1;
1643
1644         FILEDESC_XLOCK_ASSERT(fdp);
1645
1646         nfd1 = fdp->fd_nfiles * 2;
1647         if (nfd1 < nfd)
1648                 nfd1 = nfd;
1649         fdgrowtable(fdp, nfd1);
1650 }
1651
1652 /*
1653  * Grow the file table to accommodate (at least) nfd descriptors.
1654  */
1655 static void
1656 fdgrowtable(struct filedesc *fdp, int nfd)
1657 {
1658         struct filedesc0 *fdp0;
1659         struct freetable *ft;
1660         struct fdescenttbl *ntable;
1661         struct fdescenttbl *otable;
1662         int nnfiles, onfiles;
1663         NDSLOTTYPE *nmap, *omap;
1664
1665         /*
1666          * If lastfile is -1 this struct filedesc was just allocated and we are
1667          * growing it to accommodate for the one we are going to copy from. There
1668          * is no need to have a lock on this one as it's not visible to anyone.
1669          */
1670         if (fdp->fd_lastfile != -1)
1671                 FILEDESC_XLOCK_ASSERT(fdp);
1672
1673         KASSERT(fdp->fd_nfiles > 0, ("zero-length file table"));
1674
1675         /* save old values */
1676         onfiles = fdp->fd_nfiles;
1677         otable = fdp->fd_files;
1678         omap = fdp->fd_map;
1679
1680         /* compute the size of the new table */
1681         nnfiles = NDSLOTS(nfd) * NDENTRIES; /* round up */
1682         if (nnfiles <= onfiles)
1683                 /* the table is already large enough */
1684                 return;
1685
1686         /*
1687          * Allocate a new table.  We need enough space for the number of
1688          * entries, file entries themselves and the struct freetable we will use
1689          * when we decommission the table and place it on the freelist.
1690          * We place the struct freetable in the middle so we don't have
1691          * to worry about padding.
1692          */
1693         ntable = malloc(offsetof(struct fdescenttbl, fdt_ofiles) +
1694             nnfiles * sizeof(ntable->fdt_ofiles[0]) +
1695             sizeof(struct freetable),
1696             M_FILEDESC, M_ZERO | M_WAITOK);
1697         /* copy the old data */
1698         ntable->fdt_nfiles = nnfiles;
1699         memcpy(ntable->fdt_ofiles, otable->fdt_ofiles,
1700             onfiles * sizeof(ntable->fdt_ofiles[0]));
1701
1702         /*
1703          * Allocate a new map only if the old is not large enough.  It will
1704          * grow at a slower rate than the table as it can map more
1705          * entries than the table can hold.
1706          */
1707         if (NDSLOTS(nnfiles) > NDSLOTS(onfiles)) {
1708                 nmap = malloc(NDSLOTS(nnfiles) * NDSLOTSIZE, M_FILEDESC,
1709                     M_ZERO | M_WAITOK);
1710                 /* copy over the old data and update the pointer */
1711                 memcpy(nmap, omap, NDSLOTS(onfiles) * sizeof(*omap));
1712                 fdp->fd_map = nmap;
1713         }
1714
1715         /*
1716          * Make sure that ntable is correctly initialized before we replace
1717          * fd_files poiner. Otherwise fget_unlocked() may see inconsistent
1718          * data.
1719          */
1720         atomic_store_rel_ptr((volatile void *)&fdp->fd_files, (uintptr_t)ntable);
1721
1722         /*
1723          * Do not free the old file table, as some threads may still
1724          * reference entries within it.  Instead, place it on a freelist
1725          * which will be processed when the struct filedesc is released.
1726          *
1727          * Note that if onfiles == NDFILE, we're dealing with the original
1728          * static allocation contained within (struct filedesc0 *)fdp,
1729          * which must not be freed.
1730          */
1731         if (onfiles > NDFILE) {
1732                 ft = (struct freetable *)&otable->fdt_ofiles[onfiles];
1733                 fdp0 = (struct filedesc0 *)fdp;
1734                 ft->ft_table = otable;
1735                 SLIST_INSERT_HEAD(&fdp0->fd_free, ft, ft_next);
1736         }
1737         /*
1738          * The map does not have the same possibility of threads still
1739          * holding references to it.  So always free it as long as it
1740          * does not reference the original static allocation.
1741          */
1742         if (NDSLOTS(onfiles) > NDSLOTS(NDFILE))
1743                 free(omap, M_FILEDESC);
1744 }
1745
1746 /*
1747  * Allocate a file descriptor for the process.
1748  */
1749 int
1750 fdalloc(struct thread *td, int minfd, int *result)
1751 {
1752         struct proc *p = td->td_proc;
1753         struct filedesc *fdp = p->p_fd;
1754         int fd, maxfd, allocfd;
1755 #ifdef RACCT
1756         int error;
1757 #endif
1758
1759         FILEDESC_XLOCK_ASSERT(fdp);
1760
1761         if (fdp->fd_freefile > minfd)
1762                 minfd = fdp->fd_freefile;
1763
1764         maxfd = getmaxfd(td);
1765
1766         /*
1767          * Search the bitmap for a free descriptor starting at minfd.
1768          * If none is found, grow the file table.
1769          */
1770         fd = fd_first_free(fdp, minfd, fdp->fd_nfiles);
1771         if (fd >= maxfd)
1772                 return (EMFILE);
1773         if (fd >= fdp->fd_nfiles) {
1774                 allocfd = min(fd * 2, maxfd);
1775 #ifdef RACCT
1776                 if (RACCT_ENABLED()) {
1777                         error = racct_set_unlocked(p, RACCT_NOFILE, allocfd);
1778                         if (error != 0)
1779                                 return (EMFILE);
1780                 }
1781 #endif
1782                 /*
1783                  * fd is already equal to first free descriptor >= minfd, so
1784                  * we only need to grow the table and we are done.
1785                  */
1786                 fdgrowtable_exp(fdp, allocfd);
1787         }
1788
1789         /*
1790          * Perform some sanity checks, then mark the file descriptor as
1791          * used and return it to the caller.
1792          */
1793         KASSERT(fd >= 0 && fd < min(maxfd, fdp->fd_nfiles),
1794             ("invalid descriptor %d", fd));
1795         KASSERT(!fdisused(fdp, fd),
1796             ("fd_first_free() returned non-free descriptor"));
1797         KASSERT(fdp->fd_ofiles[fd].fde_file == NULL,
1798             ("file descriptor isn't free"));
1799         fdused(fdp, fd);
1800         *result = fd;
1801         return (0);
1802 }
1803
1804 /*
1805  * Allocate n file descriptors for the process.
1806  */
1807 int
1808 fdallocn(struct thread *td, int minfd, int *fds, int n)
1809 {
1810         struct proc *p = td->td_proc;
1811         struct filedesc *fdp = p->p_fd;
1812         int i;
1813
1814         FILEDESC_XLOCK_ASSERT(fdp);
1815
1816         for (i = 0; i < n; i++)
1817                 if (fdalloc(td, 0, &fds[i]) != 0)
1818                         break;
1819
1820         if (i < n) {
1821                 for (i--; i >= 0; i--)
1822                         fdunused(fdp, fds[i]);
1823                 return (EMFILE);
1824         }
1825
1826         return (0);
1827 }
1828
1829 /*
1830  * Create a new open file structure and allocate a file descriptor for the
1831  * process that refers to it.  We add one reference to the file for the
1832  * descriptor table and one reference for resultfp. This is to prevent us
1833  * being preempted and the entry in the descriptor table closed after we
1834  * release the FILEDESC lock.
1835  */
1836 int
1837 falloc_caps(struct thread *td, struct file **resultfp, int *resultfd, int flags,
1838     struct filecaps *fcaps)
1839 {
1840         struct file *fp;
1841         int error, fd;
1842
1843         error = falloc_noinstall(td, &fp);
1844         if (error)
1845                 return (error);         /* no reference held on error */
1846
1847         error = finstall(td, fp, &fd, flags, fcaps);
1848         if (error) {
1849                 fdrop(fp, td);          /* one reference (fp only) */
1850                 return (error);
1851         }
1852
1853         if (resultfp != NULL)
1854                 *resultfp = fp;         /* copy out result */
1855         else
1856                 fdrop(fp, td);          /* release local reference */
1857
1858         if (resultfd != NULL)
1859                 *resultfd = fd;
1860
1861         return (0);
1862 }
1863
1864 /*
1865  * Create a new open file structure without allocating a file descriptor.
1866  */
1867 int
1868 falloc_noinstall(struct thread *td, struct file **resultfp)
1869 {
1870         struct file *fp;
1871         int maxuserfiles = maxfiles - (maxfiles / 20);
1872         int openfiles_new;
1873         static struct timeval lastfail;
1874         static int curfail;
1875
1876         KASSERT(resultfp != NULL, ("%s: resultfp == NULL", __func__));
1877
1878         openfiles_new = atomic_fetchadd_int(&openfiles, 1) + 1;
1879         if ((openfiles_new >= maxuserfiles &&
1880             priv_check(td, PRIV_MAXFILES) != 0) ||
1881             openfiles_new >= maxfiles) {
1882                 atomic_subtract_int(&openfiles, 1);
1883                 if (ppsratecheck(&lastfail, &curfail, 1)) {
1884                         printf("kern.maxfiles limit exceeded by uid %i, (%s) "
1885                             "please see tuning(7).\n", td->td_ucred->cr_ruid, td->td_proc->p_comm);
1886                 }
1887                 return (ENFILE);
1888         }
1889         fp = uma_zalloc(file_zone, M_WAITOK);
1890         bzero(fp, sizeof(*fp));
1891         refcount_init(&fp->f_count, 1);
1892         fp->f_cred = crhold(td->td_ucred);
1893         fp->f_ops = &badfileops;
1894         *resultfp = fp;
1895         return (0);
1896 }
1897
1898 /*
1899  * Install a file in a file descriptor table.
1900  */
1901 void
1902 _finstall(struct filedesc *fdp, struct file *fp, int fd, int flags,
1903     struct filecaps *fcaps)
1904 {
1905         struct filedescent *fde;
1906
1907         MPASS(fp != NULL);
1908         if (fcaps != NULL)
1909                 filecaps_validate(fcaps, __func__);
1910         FILEDESC_XLOCK_ASSERT(fdp);
1911
1912         fde = &fdp->fd_ofiles[fd];
1913 #ifdef CAPABILITIES
1914         seqc_write_begin(&fde->fde_seqc);
1915 #endif
1916         fde->fde_file = fp;
1917         fde->fde_flags = (flags & O_CLOEXEC) != 0 ? UF_EXCLOSE : 0;
1918         if (fcaps != NULL)
1919                 filecaps_move(fcaps, &fde->fde_caps);
1920         else
1921                 filecaps_fill(&fde->fde_caps);
1922 #ifdef CAPABILITIES
1923         seqc_write_end(&fde->fde_seqc);
1924 #endif
1925 }
1926
1927 int
1928 finstall(struct thread *td, struct file *fp, int *fd, int flags,
1929     struct filecaps *fcaps)
1930 {
1931         struct filedesc *fdp = td->td_proc->p_fd;
1932         int error;
1933
1934         MPASS(fd != NULL);
1935
1936         if (!fhold(fp))
1937                 return (EBADF);
1938         FILEDESC_XLOCK(fdp);
1939         if ((error = fdalloc(td, 0, fd))) {
1940                 FILEDESC_XUNLOCK(fdp);
1941                 fdrop(fp, td);
1942                 return (error);
1943         }
1944         _finstall(fdp, fp, *fd, flags, fcaps);
1945         FILEDESC_XUNLOCK(fdp);
1946         return (0);
1947 }
1948
1949 /*
1950  * Build a new filedesc structure from another.
1951  * Copy the current, root, and jail root vnode references.
1952  *
1953  * If fdp is not NULL, return with it shared locked.
1954  */
1955 struct filedesc *
1956 fdinit(struct filedesc *fdp, bool prepfiles)
1957 {
1958         struct filedesc0 *newfdp0;
1959         struct filedesc *newfdp;
1960
1961         newfdp0 = uma_zalloc(filedesc0_zone, M_WAITOK | M_ZERO);
1962         newfdp = &newfdp0->fd_fd;
1963
1964         /* Create the file descriptor table. */
1965         FILEDESC_LOCK_INIT(newfdp);
1966         refcount_init(&newfdp->fd_refcnt, 1);
1967         refcount_init(&newfdp->fd_holdcnt, 1);
1968         newfdp->fd_cmask = CMASK;
1969         newfdp->fd_map = newfdp0->fd_dmap;
1970         newfdp->fd_lastfile = -1;
1971         newfdp->fd_files = (struct fdescenttbl *)&newfdp0->fd_dfiles;
1972         newfdp->fd_files->fdt_nfiles = NDFILE;
1973
1974         if (fdp == NULL)
1975                 return (newfdp);
1976
1977         if (prepfiles && fdp->fd_lastfile >= newfdp->fd_nfiles)
1978                 fdgrowtable(newfdp, fdp->fd_lastfile + 1);
1979
1980         FILEDESC_SLOCK(fdp);
1981         newfdp->fd_cdir = fdp->fd_cdir;
1982         if (newfdp->fd_cdir)
1983                 vrefact(newfdp->fd_cdir);
1984         newfdp->fd_rdir = fdp->fd_rdir;
1985         if (newfdp->fd_rdir)
1986                 vrefact(newfdp->fd_rdir);
1987         newfdp->fd_jdir = fdp->fd_jdir;
1988         if (newfdp->fd_jdir)
1989                 vrefact(newfdp->fd_jdir);
1990
1991         if (!prepfiles) {
1992                 FILEDESC_SUNLOCK(fdp);
1993         } else {
1994                 while (fdp->fd_lastfile >= newfdp->fd_nfiles) {
1995                         FILEDESC_SUNLOCK(fdp);
1996                         fdgrowtable(newfdp, fdp->fd_lastfile + 1);
1997                         FILEDESC_SLOCK(fdp);
1998                 }
1999         }
2000
2001         return (newfdp);
2002 }
2003
2004 static struct filedesc *
2005 fdhold(struct proc *p)
2006 {
2007         struct filedesc *fdp;
2008
2009         PROC_LOCK_ASSERT(p, MA_OWNED);
2010         fdp = p->p_fd;
2011         if (fdp != NULL)
2012                 refcount_acquire(&fdp->fd_holdcnt);
2013         return (fdp);
2014 }
2015
2016 static void
2017 fddrop(struct filedesc *fdp)
2018 {
2019
2020         if (fdp->fd_holdcnt > 1) {
2021                 if (refcount_release(&fdp->fd_holdcnt) == 0)
2022                         return;
2023         }
2024
2025         FILEDESC_LOCK_DESTROY(fdp);
2026         uma_zfree(filedesc0_zone, fdp);
2027 }
2028
2029 /*
2030  * Share a filedesc structure.
2031  */
2032 struct filedesc *
2033 fdshare(struct filedesc *fdp)
2034 {
2035
2036         refcount_acquire(&fdp->fd_refcnt);
2037         return (fdp);
2038 }
2039
2040 /*
2041  * Unshare a filedesc structure, if necessary by making a copy
2042  */
2043 void
2044 fdunshare(struct thread *td)
2045 {
2046         struct filedesc *tmp;
2047         struct proc *p = td->td_proc;
2048
2049         if (p->p_fd->fd_refcnt == 1)
2050                 return;
2051
2052         tmp = fdcopy(p->p_fd);
2053         fdescfree(td);
2054         p->p_fd = tmp;
2055 }
2056
2057 void
2058 fdinstall_remapped(struct thread *td, struct filedesc *fdp)
2059 {
2060
2061         fdescfree(td);
2062         td->td_proc->p_fd = fdp;
2063 }
2064
2065 /*
2066  * Copy a filedesc structure.  A NULL pointer in returns a NULL reference,
2067  * this is to ease callers, not catch errors.
2068  */
2069 struct filedesc *
2070 fdcopy(struct filedesc *fdp)
2071 {
2072         struct filedesc *newfdp;
2073         struct filedescent *nfde, *ofde;
2074         int i;
2075
2076         MPASS(fdp != NULL);
2077
2078         newfdp = fdinit(fdp, true);
2079         /* copy all passable descriptors (i.e. not kqueue) */
2080         newfdp->fd_freefile = -1;
2081         for (i = 0; i <= fdp->fd_lastfile; ++i) {
2082                 ofde = &fdp->fd_ofiles[i];
2083                 if (ofde->fde_file == NULL ||
2084                     (ofde->fde_file->f_ops->fo_flags & DFLAG_PASSABLE) == 0 ||
2085                     !fhold(ofde->fde_file)) {
2086                         if (newfdp->fd_freefile == -1)
2087                                 newfdp->fd_freefile = i;
2088                         continue;
2089                 }
2090                 nfde = &newfdp->fd_ofiles[i];
2091                 *nfde = *ofde;
2092                 filecaps_copy(&ofde->fde_caps, &nfde->fde_caps, true);
2093                 fdused_init(newfdp, i);
2094                 newfdp->fd_lastfile = i;
2095         }
2096         if (newfdp->fd_freefile == -1)
2097                 newfdp->fd_freefile = i;
2098         newfdp->fd_cmask = fdp->fd_cmask;
2099         FILEDESC_SUNLOCK(fdp);
2100         return (newfdp);
2101 }
2102
2103 /*
2104  * Copies a filedesc structure, while remapping all file descriptors
2105  * stored inside using a translation table.
2106  *
2107  * File descriptors are copied over to the new file descriptor table,
2108  * regardless of whether the close-on-exec flag is set.
2109  */
2110 int
2111 fdcopy_remapped(struct filedesc *fdp, const int *fds, size_t nfds,
2112     struct filedesc **ret)
2113 {
2114         struct filedesc *newfdp;
2115         struct filedescent *nfde, *ofde;
2116         int error, i;
2117
2118         MPASS(fdp != NULL);
2119
2120         newfdp = fdinit(fdp, true);
2121         if (nfds > fdp->fd_lastfile + 1) {
2122                 /* New table cannot be larger than the old one. */
2123                 error = E2BIG;
2124                 goto bad;
2125         }
2126         /* Copy all passable descriptors (i.e. not kqueue). */
2127         newfdp->fd_freefile = nfds;
2128         for (i = 0; i < nfds; ++i) {
2129                 if (fds[i] < 0 || fds[i] > fdp->fd_lastfile) {
2130                         /* File descriptor out of bounds. */
2131                         error = EBADF;
2132                         goto bad;
2133                 }
2134                 ofde = &fdp->fd_ofiles[fds[i]];
2135                 if (ofde->fde_file == NULL) {
2136                         /* Unused file descriptor. */
2137                         error = EBADF;
2138                         goto bad;
2139                 }
2140                 if ((ofde->fde_file->f_ops->fo_flags & DFLAG_PASSABLE) == 0) {
2141                         /* File descriptor cannot be passed. */
2142                         error = EINVAL;
2143                         goto bad;
2144                 }
2145                 if (!fhold(nfde->fde_file)) {
2146                         error = EBADF;
2147                         goto bad;
2148                 }
2149                 nfde = &newfdp->fd_ofiles[i];
2150                 *nfde = *ofde;
2151                 filecaps_copy(&ofde->fde_caps, &nfde->fde_caps, true);
2152                 fdused_init(newfdp, i);
2153                 newfdp->fd_lastfile = i;
2154         }
2155         newfdp->fd_cmask = fdp->fd_cmask;
2156         FILEDESC_SUNLOCK(fdp);
2157         *ret = newfdp;
2158         return (0);
2159 bad:
2160         FILEDESC_SUNLOCK(fdp);
2161         fdescfree_remapped(newfdp);
2162         return (error);
2163 }
2164
2165 /*
2166  * Clear POSIX style locks. This is only used when fdp looses a reference (i.e.
2167  * one of processes using it exits) and the table used to be shared.
2168  */
2169 static void
2170 fdclearlocks(struct thread *td)
2171 {
2172         struct filedesc *fdp;
2173         struct filedesc_to_leader *fdtol;
2174         struct flock lf;
2175         struct file *fp;
2176         struct proc *p;
2177         struct vnode *vp;
2178         int i;
2179
2180         p = td->td_proc;
2181         fdp = p->p_fd;
2182         fdtol = p->p_fdtol;
2183         MPASS(fdtol != NULL);
2184
2185         FILEDESC_XLOCK(fdp);
2186         KASSERT(fdtol->fdl_refcount > 0,
2187             ("filedesc_to_refcount botch: fdl_refcount=%d",
2188             fdtol->fdl_refcount));
2189         if (fdtol->fdl_refcount == 1 &&
2190             (p->p_leader->p_flag & P_ADVLOCK) != 0) {
2191                 for (i = 0; i <= fdp->fd_lastfile; i++) {
2192                         fp = fdp->fd_ofiles[i].fde_file;
2193                         if (fp == NULL || fp->f_type != DTYPE_VNODE ||
2194                             !fhold(fp))
2195                                 continue;
2196                         FILEDESC_XUNLOCK(fdp);
2197                         lf.l_whence = SEEK_SET;
2198                         lf.l_start = 0;
2199                         lf.l_len = 0;
2200                         lf.l_type = F_UNLCK;
2201                         vp = fp->f_vnode;
2202                         (void) VOP_ADVLOCK(vp,
2203                             (caddr_t)p->p_leader, F_UNLCK,
2204                             &lf, F_POSIX);
2205                         FILEDESC_XLOCK(fdp);
2206                         fdrop(fp, td);
2207                 }
2208         }
2209 retry:
2210         if (fdtol->fdl_refcount == 1) {
2211                 if (fdp->fd_holdleaderscount > 0 &&
2212                     (p->p_leader->p_flag & P_ADVLOCK) != 0) {
2213                         /*
2214                          * close() or kern_dup() has cleared a reference
2215                          * in a shared file descriptor table.
2216                          */
2217                         fdp->fd_holdleaderswakeup = 1;
2218                         sx_sleep(&fdp->fd_holdleaderscount,
2219                             FILEDESC_LOCK(fdp), PLOCK, "fdlhold", 0);
2220                         goto retry;
2221                 }
2222                 if (fdtol->fdl_holdcount > 0) {
2223                         /*
2224                          * Ensure that fdtol->fdl_leader remains
2225                          * valid in closef().
2226                          */
2227                         fdtol->fdl_wakeup = 1;
2228                         sx_sleep(fdtol, FILEDESC_LOCK(fdp), PLOCK,
2229                             "fdlhold", 0);
2230                         goto retry;
2231                 }
2232         }
2233         fdtol->fdl_refcount--;
2234         if (fdtol->fdl_refcount == 0 &&
2235             fdtol->fdl_holdcount == 0) {
2236                 fdtol->fdl_next->fdl_prev = fdtol->fdl_prev;
2237                 fdtol->fdl_prev->fdl_next = fdtol->fdl_next;
2238         } else
2239                 fdtol = NULL;
2240         p->p_fdtol = NULL;
2241         FILEDESC_XUNLOCK(fdp);
2242         if (fdtol != NULL)
2243                 free(fdtol, M_FILEDESC_TO_LEADER);
2244 }
2245
2246 /*
2247  * Release a filedesc structure.
2248  */
2249 static void
2250 fdescfree_fds(struct thread *td, struct filedesc *fdp, bool needclose)
2251 {
2252         struct filedesc0 *fdp0;
2253         struct freetable *ft, *tft;
2254         struct filedescent *fde;
2255         struct file *fp;
2256         int i;
2257
2258         for (i = 0; i <= fdp->fd_lastfile; i++) {
2259                 fde = &fdp->fd_ofiles[i];
2260                 fp = fde->fde_file;
2261                 if (fp != NULL) {
2262                         fdefree_last(fde);
2263                         if (needclose)
2264                                 (void) closef(fp, td);
2265                         else
2266                                 fdrop(fp, td);
2267                 }
2268         }
2269
2270         if (NDSLOTS(fdp->fd_nfiles) > NDSLOTS(NDFILE))
2271                 free(fdp->fd_map, M_FILEDESC);
2272         if (fdp->fd_nfiles > NDFILE)
2273                 free(fdp->fd_files, M_FILEDESC);
2274
2275         fdp0 = (struct filedesc0 *)fdp;
2276         SLIST_FOREACH_SAFE(ft, &fdp0->fd_free, ft_next, tft)
2277                 free(ft->ft_table, M_FILEDESC);
2278
2279         fddrop(fdp);
2280 }
2281
2282 void
2283 fdescfree(struct thread *td)
2284 {
2285         struct proc *p;
2286         struct filedesc *fdp;
2287         struct vnode *cdir, *jdir, *rdir;
2288
2289         p = td->td_proc;
2290         fdp = p->p_fd;
2291         MPASS(fdp != NULL);
2292
2293 #ifdef RACCT
2294         if (RACCT_ENABLED())
2295                 racct_set_unlocked(p, RACCT_NOFILE, 0);
2296 #endif
2297
2298         if (p->p_fdtol != NULL)
2299                 fdclearlocks(td);
2300
2301         PROC_LOCK(p);
2302         p->p_fd = NULL;
2303         PROC_UNLOCK(p);
2304
2305         if (refcount_release(&fdp->fd_refcnt) == 0)
2306                 return;
2307
2308         FILEDESC_XLOCK(fdp);
2309         cdir = fdp->fd_cdir;
2310         fdp->fd_cdir = NULL;
2311         rdir = fdp->fd_rdir;
2312         fdp->fd_rdir = NULL;
2313         jdir = fdp->fd_jdir;
2314         fdp->fd_jdir = NULL;
2315         FILEDESC_XUNLOCK(fdp);
2316
2317         if (cdir != NULL)
2318                 vrele(cdir);
2319         if (rdir != NULL)
2320                 vrele(rdir);
2321         if (jdir != NULL)
2322                 vrele(jdir);
2323
2324         fdescfree_fds(td, fdp, 1);
2325 }
2326
2327 void
2328 fdescfree_remapped(struct filedesc *fdp)
2329 {
2330
2331         if (fdp->fd_cdir != NULL)
2332                 vrele(fdp->fd_cdir);
2333         if (fdp->fd_rdir != NULL)
2334                 vrele(fdp->fd_rdir);
2335         if (fdp->fd_jdir != NULL)
2336                 vrele(fdp->fd_jdir);
2337
2338         fdescfree_fds(curthread, fdp, 0);
2339 }
2340
2341 /*
2342  * For setugid programs, we don't want to people to use that setugidness
2343  * to generate error messages which write to a file which otherwise would
2344  * otherwise be off-limits to the process.  We check for filesystems where
2345  * the vnode can change out from under us after execve (like [lin]procfs).
2346  *
2347  * Since fdsetugidsafety calls this only for fd 0, 1 and 2, this check is
2348  * sufficient.  We also don't check for setugidness since we know we are.
2349  */
2350 static bool
2351 is_unsafe(struct file *fp)
2352 {
2353         struct vnode *vp;
2354
2355         if (fp->f_type != DTYPE_VNODE)
2356                 return (false);
2357
2358         vp = fp->f_vnode;
2359         return ((vp->v_vflag & VV_PROCDEP) != 0);
2360 }
2361
2362 /*
2363  * Make this setguid thing safe, if at all possible.
2364  */
2365 void
2366 fdsetugidsafety(struct thread *td)
2367 {
2368         struct filedesc *fdp;
2369         struct file *fp;
2370         int i;
2371
2372         fdp = td->td_proc->p_fd;
2373         KASSERT(fdp->fd_refcnt == 1, ("the fdtable should not be shared"));
2374         MPASS(fdp->fd_nfiles >= 3);
2375         for (i = 0; i <= 2; i++) {
2376                 fp = fdp->fd_ofiles[i].fde_file;
2377                 if (fp != NULL && is_unsafe(fp)) {
2378                         FILEDESC_XLOCK(fdp);
2379                         knote_fdclose(td, i);
2380                         /*
2381                          * NULL-out descriptor prior to close to avoid
2382                          * a race while close blocks.
2383                          */
2384                         fdfree(fdp, i);
2385                         FILEDESC_XUNLOCK(fdp);
2386                         (void) closef(fp, td);
2387                 }
2388         }
2389 }
2390
2391 /*
2392  * If a specific file object occupies a specific file descriptor, close the
2393  * file descriptor entry and drop a reference on the file object.  This is a
2394  * convenience function to handle a subsequent error in a function that calls
2395  * falloc() that handles the race that another thread might have closed the
2396  * file descriptor out from under the thread creating the file object.
2397  */
2398 void
2399 fdclose(struct thread *td, struct file *fp, int idx)
2400 {
2401         struct filedesc *fdp = td->td_proc->p_fd;
2402
2403         FILEDESC_XLOCK(fdp);
2404         if (fdp->fd_ofiles[idx].fde_file == fp) {
2405                 fdfree(fdp, idx);
2406                 FILEDESC_XUNLOCK(fdp);
2407                 fdrop(fp, td);
2408         } else
2409                 FILEDESC_XUNLOCK(fdp);
2410 }
2411
2412 /*
2413  * Close any files on exec?
2414  */
2415 void
2416 fdcloseexec(struct thread *td)
2417 {
2418         struct filedesc *fdp;
2419         struct filedescent *fde;
2420         struct file *fp;
2421         int i;
2422
2423         fdp = td->td_proc->p_fd;
2424         KASSERT(fdp->fd_refcnt == 1, ("the fdtable should not be shared"));
2425         for (i = 0; i <= fdp->fd_lastfile; i++) {
2426                 fde = &fdp->fd_ofiles[i];
2427                 fp = fde->fde_file;
2428                 if (fp != NULL && (fp->f_type == DTYPE_MQUEUE ||
2429                     (fde->fde_flags & UF_EXCLOSE))) {
2430                         FILEDESC_XLOCK(fdp);
2431                         fdfree(fdp, i);
2432                         (void) closefp(fdp, i, fp, td, 0);
2433                         FILEDESC_UNLOCK_ASSERT(fdp);
2434                 }
2435         }
2436 }
2437
2438 /*
2439  * It is unsafe for set[ug]id processes to be started with file
2440  * descriptors 0..2 closed, as these descriptors are given implicit
2441  * significance in the Standard C library.  fdcheckstd() will create a
2442  * descriptor referencing /dev/null for each of stdin, stdout, and
2443  * stderr that is not already open.
2444  */
2445 int
2446 fdcheckstd(struct thread *td)
2447 {
2448         struct filedesc *fdp;
2449         register_t save;
2450         int i, error, devnull;
2451
2452         fdp = td->td_proc->p_fd;
2453         KASSERT(fdp->fd_refcnt == 1, ("the fdtable should not be shared"));
2454         MPASS(fdp->fd_nfiles >= 3);
2455         devnull = -1;
2456         for (i = 0; i <= 2; i++) {
2457                 if (fdp->fd_ofiles[i].fde_file != NULL)
2458                         continue;
2459
2460                 save = td->td_retval[0];
2461                 if (devnull != -1) {
2462                         error = kern_dup(td, FDDUP_FIXED, 0, devnull, i);
2463                 } else {
2464                         error = kern_openat(td, AT_FDCWD, "/dev/null",
2465                             UIO_SYSSPACE, O_RDWR, 0);
2466                         if (error == 0) {
2467                                 devnull = td->td_retval[0];
2468                                 KASSERT(devnull == i, ("we didn't get our fd"));
2469                         }
2470                 }
2471                 td->td_retval[0] = save;
2472                 if (error != 0)
2473                         return (error);
2474         }
2475         return (0);
2476 }
2477
2478 /*
2479  * Internal form of close.  Decrement reference count on file structure.
2480  * Note: td may be NULL when closing a file that was being passed in a
2481  * message.
2482  */
2483 int
2484 closef(struct file *fp, struct thread *td)
2485 {
2486         struct vnode *vp;
2487         struct flock lf;
2488         struct filedesc_to_leader *fdtol;
2489         struct filedesc *fdp;
2490
2491         /*
2492          * POSIX record locking dictates that any close releases ALL
2493          * locks owned by this process.  This is handled by setting
2494          * a flag in the unlock to free ONLY locks obeying POSIX
2495          * semantics, and not to free BSD-style file locks.
2496          * If the descriptor was in a message, POSIX-style locks
2497          * aren't passed with the descriptor, and the thread pointer
2498          * will be NULL.  Callers should be careful only to pass a
2499          * NULL thread pointer when there really is no owning
2500          * context that might have locks, or the locks will be
2501          * leaked.
2502          */
2503         if (fp->f_type == DTYPE_VNODE && td != NULL) {
2504                 vp = fp->f_vnode;
2505                 if ((td->td_proc->p_leader->p_flag & P_ADVLOCK) != 0) {
2506                         lf.l_whence = SEEK_SET;
2507                         lf.l_start = 0;
2508                         lf.l_len = 0;
2509                         lf.l_type = F_UNLCK;
2510                         (void) VOP_ADVLOCK(vp, (caddr_t)td->td_proc->p_leader,
2511                             F_UNLCK, &lf, F_POSIX);
2512                 }
2513                 fdtol = td->td_proc->p_fdtol;
2514                 if (fdtol != NULL) {
2515                         /*
2516                          * Handle special case where file descriptor table is
2517                          * shared between multiple process leaders.
2518                          */
2519                         fdp = td->td_proc->p_fd;
2520                         FILEDESC_XLOCK(fdp);
2521                         for (fdtol = fdtol->fdl_next;
2522                             fdtol != td->td_proc->p_fdtol;
2523                             fdtol = fdtol->fdl_next) {
2524                                 if ((fdtol->fdl_leader->p_flag &
2525                                     P_ADVLOCK) == 0)
2526                                         continue;
2527                                 fdtol->fdl_holdcount++;
2528                                 FILEDESC_XUNLOCK(fdp);
2529                                 lf.l_whence = SEEK_SET;
2530                                 lf.l_start = 0;
2531                                 lf.l_len = 0;
2532                                 lf.l_type = F_UNLCK;
2533                                 vp = fp->f_vnode;
2534                                 (void) VOP_ADVLOCK(vp,
2535                                     (caddr_t)fdtol->fdl_leader, F_UNLCK, &lf,
2536                                     F_POSIX);
2537                                 FILEDESC_XLOCK(fdp);
2538                                 fdtol->fdl_holdcount--;
2539                                 if (fdtol->fdl_holdcount == 0 &&
2540                                     fdtol->fdl_wakeup != 0) {
2541                                         fdtol->fdl_wakeup = 0;
2542                                         wakeup(fdtol);
2543                                 }
2544                         }
2545                         FILEDESC_XUNLOCK(fdp);
2546                 }
2547         }
2548         return (fdrop(fp, td));
2549 }
2550
2551 /*
2552  * Initialize the file pointer with the specified properties.
2553  *
2554  * The ops are set with release semantics to be certain that the flags, type,
2555  * and data are visible when ops is.  This is to prevent ops methods from being
2556  * called with bad data.
2557  */
2558 void
2559 finit(struct file *fp, u_int flag, short type, void *data, struct fileops *ops)
2560 {
2561         fp->f_data = data;
2562         fp->f_flag = flag;
2563         fp->f_type = type;
2564         atomic_store_rel_ptr((volatile uintptr_t *)&fp->f_ops, (uintptr_t)ops);
2565 }
2566
2567 int
2568 fget_cap_locked(struct filedesc *fdp, int fd, cap_rights_t *needrightsp,
2569     struct file **fpp, struct filecaps *havecapsp)
2570 {
2571         struct filedescent *fde;
2572         int error;
2573
2574         FILEDESC_LOCK_ASSERT(fdp);
2575
2576         fde = fdeget_locked(fdp, fd);
2577         if (fde == NULL) {
2578                 error = EBADF;
2579                 goto out;
2580         }
2581
2582 #ifdef CAPABILITIES
2583         error = cap_check(cap_rights_fde_inline(fde), needrightsp);
2584         if (error != 0)
2585                 goto out;
2586 #endif
2587
2588         if (havecapsp != NULL)
2589                 filecaps_copy(&fde->fde_caps, havecapsp, true);
2590
2591         *fpp = fde->fde_file;
2592
2593         error = 0;
2594 out:
2595         return (error);
2596 }
2597
2598 int
2599 fget_cap(struct thread *td, int fd, cap_rights_t *needrightsp,
2600     struct file **fpp, struct filecaps *havecapsp)
2601 {
2602         struct filedesc *fdp = td->td_proc->p_fd;
2603         int error;
2604 #ifndef CAPABILITIES
2605         error = fget_unlocked(fdp, fd, needrightsp, fpp, NULL);
2606         if (error == 0 && havecapsp != NULL)
2607                 filecaps_fill(havecapsp);
2608 #else
2609         struct file *fp;
2610         seqc_t seq;
2611
2612         for (;;) {
2613                 error = fget_unlocked(fdp, fd, needrightsp, &fp, &seq);
2614                 if (error != 0)
2615                         return (error);
2616
2617                 if (havecapsp != NULL) {
2618                         if (!filecaps_copy(&fdp->fd_ofiles[fd].fde_caps,
2619                             havecapsp, false)) {
2620                                 fdrop(fp, td);
2621                                 goto get_locked;
2622                         }
2623                 }
2624
2625                 if (!fd_modified(fdp, fd, seq))
2626                         break;
2627                 fdrop(fp, td);
2628         }
2629
2630         *fpp = fp;
2631         return (0);
2632
2633 get_locked:
2634         FILEDESC_SLOCK(fdp);
2635         error = fget_cap_locked(fdp, fd, needrightsp, fpp, havecapsp);
2636         if (error == 0 && !fhold(*fpp))
2637                 error = EBADF;
2638         FILEDESC_SUNLOCK(fdp);
2639 #endif
2640         return (error);
2641 }
2642
2643 int
2644 fget_unlocked(struct filedesc *fdp, int fd, cap_rights_t *needrightsp,
2645     struct file **fpp, seqc_t *seqp)
2646 {
2647 #ifdef CAPABILITIES
2648         const struct filedescent *fde;
2649 #endif
2650         const struct fdescenttbl *fdt;
2651         struct file *fp;
2652         u_int count;
2653 #ifdef CAPABILITIES
2654         seqc_t seq;
2655         cap_rights_t haverights;
2656         int error;
2657 #endif
2658
2659         fdt = fdp->fd_files;
2660         if (__predict_false((u_int)fd >= fdt->fdt_nfiles))
2661                 return (EBADF);
2662         /*
2663          * Fetch the descriptor locklessly.  We avoid fdrop() races by
2664          * never raising a refcount above 0.  To accomplish this we have
2665          * to use a cmpset loop rather than an atomic_add.  The descriptor
2666          * must be re-verified once we acquire a reference to be certain
2667          * that the identity is still correct and we did not lose a race
2668          * due to preemption.
2669          */
2670         for (;;) {
2671 #ifdef CAPABILITIES
2672                 seq = seqc_read(fd_seqc(fdt, fd));
2673                 fde = &fdt->fdt_ofiles[fd];
2674                 haverights = *cap_rights_fde_inline(fde);
2675                 fp = fde->fde_file;
2676                 if (!seqc_consistent(fd_seqc(fdt, fd), seq))
2677                         continue;
2678 #else
2679                 fp = fdt->fdt_ofiles[fd].fde_file;
2680 #endif
2681                 if (fp == NULL)
2682                         return (EBADF);
2683 #ifdef CAPABILITIES
2684                 error = cap_check(&haverights, needrightsp);
2685                 if (error != 0)
2686                         return (error);
2687 #endif
2688                 count = fp->f_count;
2689         retry:
2690                 if (count == 0) {
2691                         /*
2692                          * Force a reload. Other thread could reallocate the
2693                          * table before this fd was closed, so it possible that
2694                          * there is a stale fp pointer in cached version.
2695                          */
2696                         fdt = *(const struct fdescenttbl * const volatile *)
2697                             &(fdp->fd_files);
2698                         continue;
2699                 }
2700                 if (__predict_false(count + 1 < count))
2701                         return (EBADF);
2702
2703                 /*
2704                  * Use an acquire barrier to force re-reading of fdt so it is
2705                  * refreshed for verification.
2706                  */
2707                 if (__predict_false(atomic_fcmpset_acq_int(&fp->f_count,
2708                     &count, count + 1) == 0))
2709                         goto retry;
2710                 fdt = fdp->fd_files;
2711 #ifdef  CAPABILITIES
2712                 if (seqc_consistent_nomb(fd_seqc(fdt, fd), seq))
2713 #else
2714                 if (fp == fdt->fdt_ofiles[fd].fde_file)
2715 #endif
2716                         break;
2717                 fdrop(fp, curthread);
2718         }
2719         *fpp = fp;
2720         if (seqp != NULL) {
2721 #ifdef CAPABILITIES
2722                 *seqp = seq;
2723 #endif
2724         }
2725         return (0);
2726 }
2727
2728 /*
2729  * Extract the file pointer associated with the specified descriptor for the
2730  * current user process.
2731  *
2732  * If the descriptor doesn't exist or doesn't match 'flags', EBADF is
2733  * returned.
2734  *
2735  * File's rights will be checked against the capability rights mask.
2736  *
2737  * If an error occurred the non-zero error is returned and *fpp is set to
2738  * NULL.  Otherwise *fpp is held and set and zero is returned.  Caller is
2739  * responsible for fdrop().
2740  */
2741 static __inline int
2742 _fget(struct thread *td, int fd, struct file **fpp, int flags,
2743     cap_rights_t *needrightsp, seqc_t *seqp)
2744 {
2745         struct filedesc *fdp;
2746         struct file *fp;
2747         int error;
2748
2749         *fpp = NULL;
2750         fdp = td->td_proc->p_fd;
2751         error = fget_unlocked(fdp, fd, needrightsp, &fp, seqp);
2752         if (error != 0)
2753                 return (error);
2754         if (fp->f_ops == &badfileops) {
2755                 fdrop(fp, td);
2756                 return (EBADF);
2757         }
2758
2759         /*
2760          * FREAD and FWRITE failure return EBADF as per POSIX.
2761          */
2762         error = 0;
2763         switch (flags) {
2764         case FREAD:
2765         case FWRITE:
2766                 if ((fp->f_flag & flags) == 0)
2767                         error = EBADF;
2768                 break;
2769         case FEXEC:
2770                 if ((fp->f_flag & (FREAD | FEXEC)) == 0 ||
2771                     ((fp->f_flag & FWRITE) != 0))
2772                         error = EBADF;
2773                 break;
2774         case 0:
2775                 break;
2776         default:
2777                 KASSERT(0, ("wrong flags"));
2778         }
2779
2780         if (error != 0) {
2781                 fdrop(fp, td);
2782                 return (error);
2783         }
2784
2785         *fpp = fp;
2786         return (0);
2787 }
2788
2789 int
2790 fget(struct thread *td, int fd, cap_rights_t *rightsp, struct file **fpp)
2791 {
2792
2793         return (_fget(td, fd, fpp, 0, rightsp, NULL));
2794 }
2795
2796 int
2797 fget_mmap(struct thread *td, int fd, cap_rights_t *rightsp, u_char *maxprotp,
2798     struct file **fpp)
2799 {
2800         int error;
2801 #ifndef CAPABILITIES
2802         error = _fget(td, fd, fpp, 0, rightsp, NULL);
2803         if (maxprotp != NULL)
2804                 *maxprotp = VM_PROT_ALL;
2805 #else
2806         cap_rights_t fdrights;
2807         struct filedesc *fdp = td->td_proc->p_fd;
2808         seqc_t seq;
2809
2810         MPASS(cap_rights_is_set(rightsp, CAP_MMAP));
2811         for (;;) {
2812                 error = _fget(td, fd, fpp, 0, rightsp, &seq);
2813                 if (error != 0)
2814                         return (error);
2815                 if (maxprotp != NULL)
2816                         fdrights = *cap_rights(fdp, fd);
2817                 if (!fd_modified(fdp, fd, seq))
2818                         break;
2819                 fdrop(*fpp, td);
2820         }
2821
2822         /*
2823          * If requested, convert capability rights to access flags.
2824          */
2825         if (maxprotp != NULL)
2826                 *maxprotp = cap_rights_to_vmprot(&fdrights);
2827 #endif
2828         return (error);
2829 }
2830
2831 int
2832 fget_read(struct thread *td, int fd, cap_rights_t *rightsp, struct file **fpp)
2833 {
2834
2835         return (_fget(td, fd, fpp, FREAD, rightsp, NULL));
2836 }
2837
2838 int
2839 fget_write(struct thread *td, int fd, cap_rights_t *rightsp, struct file **fpp)
2840 {
2841
2842         return (_fget(td, fd, fpp, FWRITE, rightsp, NULL));
2843 }
2844
2845 int
2846 fget_fcntl(struct thread *td, int fd, cap_rights_t *rightsp, int needfcntl,
2847     struct file **fpp)
2848 {
2849         struct filedesc *fdp = td->td_proc->p_fd;
2850 #ifndef CAPABILITIES
2851         return (fget_unlocked(fdp, fd, rightsp, fpp, NULL));
2852 #else
2853         int error;
2854         seqc_t seq;
2855
2856         MPASS(cap_rights_is_set(rightsp, CAP_FCNTL));
2857         for (;;) {
2858                 error = fget_unlocked(fdp, fd, rightsp, fpp, &seq);
2859                 if (error != 0)
2860                         return (error);
2861                 error = cap_fcntl_check(fdp, fd, needfcntl);
2862                 if (!fd_modified(fdp, fd, seq))
2863                         break;
2864                 fdrop(*fpp, td);
2865         }
2866         if (error != 0) {
2867                 fdrop(*fpp, td);
2868                 *fpp = NULL;
2869         }
2870         return (error);
2871 #endif
2872 }
2873
2874 /*
2875  * Like fget() but loads the underlying vnode, or returns an error if the
2876  * descriptor does not represent a vnode.  Note that pipes use vnodes but
2877  * never have VM objects.  The returned vnode will be vref()'d.
2878  *
2879  * XXX: what about the unused flags ?
2880  */
2881 static __inline int
2882 _fgetvp(struct thread *td, int fd, int flags, cap_rights_t *needrightsp,
2883     struct vnode **vpp)
2884 {
2885         struct file *fp;
2886         int error;
2887
2888         *vpp = NULL;
2889         error = _fget(td, fd, &fp, flags, needrightsp, NULL);
2890         if (error != 0)
2891                 return (error);
2892         if (fp->f_vnode == NULL) {
2893                 error = EINVAL;
2894         } else {
2895                 *vpp = fp->f_vnode;
2896                 vrefact(*vpp);
2897         }
2898         fdrop(fp, td);
2899
2900         return (error);
2901 }
2902
2903 int
2904 fgetvp(struct thread *td, int fd, cap_rights_t *rightsp, struct vnode **vpp)
2905 {
2906
2907         return (_fgetvp(td, fd, 0, rightsp, vpp));
2908 }
2909
2910 int
2911 fgetvp_rights(struct thread *td, int fd, cap_rights_t *needrightsp,
2912     struct filecaps *havecaps, struct vnode **vpp)
2913 {
2914         struct filedesc *fdp;
2915         struct filecaps caps;
2916         struct file *fp;
2917         int error;
2918
2919         fdp = td->td_proc->p_fd;
2920         error = fget_cap_locked(fdp, fd, needrightsp, &fp, &caps);
2921         if (error != 0)
2922                 return (error);
2923         if (fp->f_ops == &badfileops) {
2924                 error = EBADF;
2925                 goto out;
2926         }
2927         if (fp->f_vnode == NULL) {
2928                 error = EINVAL;
2929                 goto out;
2930         }
2931
2932         *havecaps = caps;
2933         *vpp = fp->f_vnode;
2934         vrefact(*vpp);
2935
2936         return (0);
2937 out:
2938         filecaps_free(&caps);
2939         return (error);
2940 }
2941
2942 int
2943 fgetvp_read(struct thread *td, int fd, cap_rights_t *rightsp, struct vnode **vpp)
2944 {
2945
2946         return (_fgetvp(td, fd, FREAD, rightsp, vpp));
2947 }
2948
2949 int
2950 fgetvp_exec(struct thread *td, int fd, cap_rights_t *rightsp, struct vnode **vpp)
2951 {
2952
2953         return (_fgetvp(td, fd, FEXEC, rightsp, vpp));
2954 }
2955
2956 #ifdef notyet
2957 int
2958 fgetvp_write(struct thread *td, int fd, cap_rights_t *rightsp,
2959     struct vnode **vpp)
2960 {
2961
2962         return (_fgetvp(td, fd, FWRITE, rightsp, vpp));
2963 }
2964 #endif
2965
2966 /*
2967  * Handle the last reference to a file being closed.
2968  *
2969  * Without the noinline attribute clang keeps inlining the func thorough this
2970  * file when fdrop is used.
2971  */
2972 int __noinline
2973 _fdrop(struct file *fp, struct thread *td)
2974 {
2975         int error;
2976
2977         if (fp->f_count != 0)
2978                 panic("fdrop: count %d", fp->f_count);
2979         error = fo_close(fp, td);
2980         atomic_subtract_int(&openfiles, 1);
2981         crfree(fp->f_cred);
2982         free(fp->f_advice, M_FADVISE);
2983         uma_zfree(file_zone, fp);
2984
2985         return (error);
2986 }
2987
2988 /*
2989  * Apply an advisory lock on a file descriptor.
2990  *
2991  * Just attempt to get a record lock of the requested type on the entire file
2992  * (l_whence = SEEK_SET, l_start = 0, l_len = 0).
2993  */
2994 #ifndef _SYS_SYSPROTO_H_
2995 struct flock_args {
2996         int     fd;
2997         int     how;
2998 };
2999 #endif
3000 /* ARGSUSED */
3001 int
3002 sys_flock(struct thread *td, struct flock_args *uap)
3003 {
3004         struct file *fp;
3005         struct vnode *vp;
3006         struct flock lf;
3007         int error;
3008
3009         error = fget(td, uap->fd, &cap_flock_rights, &fp);
3010         if (error != 0)
3011                 return (error);
3012         if (fp->f_type != DTYPE_VNODE) {
3013                 fdrop(fp, td);
3014                 return (EOPNOTSUPP);
3015         }
3016
3017         vp = fp->f_vnode;
3018         lf.l_whence = SEEK_SET;
3019         lf.l_start = 0;
3020         lf.l_len = 0;
3021         if (uap->how & LOCK_UN) {
3022                 lf.l_type = F_UNLCK;
3023                 atomic_clear_int(&fp->f_flag, FHASLOCK);
3024                 error = VOP_ADVLOCK(vp, (caddr_t)fp, F_UNLCK, &lf, F_FLOCK);
3025                 goto done2;
3026         }
3027         if (uap->how & LOCK_EX)
3028                 lf.l_type = F_WRLCK;
3029         else if (uap->how & LOCK_SH)
3030                 lf.l_type = F_RDLCK;
3031         else {
3032                 error = EBADF;
3033                 goto done2;
3034         }
3035         atomic_set_int(&fp->f_flag, FHASLOCK);
3036         error = VOP_ADVLOCK(vp, (caddr_t)fp, F_SETLK, &lf,
3037             (uap->how & LOCK_NB) ? F_FLOCK : F_FLOCK | F_WAIT);
3038 done2:
3039         fdrop(fp, td);
3040         return (error);
3041 }
3042 /*
3043  * Duplicate the specified descriptor to a free descriptor.
3044  */
3045 int
3046 dupfdopen(struct thread *td, struct filedesc *fdp, int dfd, int mode,
3047     int openerror, int *indxp)
3048 {
3049         struct filedescent *newfde, *oldfde;
3050         struct file *fp;
3051         u_long *ioctls;
3052         int error, indx;
3053
3054         KASSERT(openerror == ENODEV || openerror == ENXIO,
3055             ("unexpected error %d in %s", openerror, __func__));
3056
3057         /*
3058          * If the to-be-dup'd fd number is greater than the allowed number
3059          * of file descriptors, or the fd to be dup'd has already been
3060          * closed, then reject.
3061          */
3062         FILEDESC_XLOCK(fdp);
3063         if ((fp = fget_locked(fdp, dfd)) == NULL) {
3064                 FILEDESC_XUNLOCK(fdp);
3065                 return (EBADF);
3066         }
3067
3068         error = fdalloc(td, 0, &indx);
3069         if (error != 0) {
3070                 FILEDESC_XUNLOCK(fdp);
3071                 return (error);
3072         }
3073
3074         /*
3075          * There are two cases of interest here.
3076          *
3077          * For ENODEV simply dup (dfd) to file descriptor (indx) and return.
3078          *
3079          * For ENXIO steal away the file structure from (dfd) and store it in
3080          * (indx).  (dfd) is effectively closed by this operation.
3081          */
3082         switch (openerror) {
3083         case ENODEV:
3084                 /*
3085                  * Check that the mode the file is being opened for is a
3086                  * subset of the mode of the existing descriptor.
3087                  */
3088                 if (((mode & (FREAD|FWRITE)) | fp->f_flag) != fp->f_flag) {
3089                         fdunused(fdp, indx);
3090                         FILEDESC_XUNLOCK(fdp);
3091                         return (EACCES);
3092                 }
3093                 if (!fhold(fp)) {
3094                         fdunused(fdp, indx);
3095                         FILEDESC_XUNLOCK(fdp);
3096                         return (EBADF);
3097                 }
3098                 newfde = &fdp->fd_ofiles[indx];
3099                 oldfde = &fdp->fd_ofiles[dfd];
3100                 ioctls = filecaps_copy_prep(&oldfde->fde_caps);
3101 #ifdef CAPABILITIES
3102                 seqc_write_begin(&newfde->fde_seqc);
3103 #endif
3104                 memcpy(newfde, oldfde, fde_change_size);
3105                 filecaps_copy_finish(&oldfde->fde_caps, &newfde->fde_caps,
3106                     ioctls);
3107 #ifdef CAPABILITIES
3108                 seqc_write_end(&newfde->fde_seqc);
3109 #endif
3110                 break;
3111         case ENXIO:
3112                 /*
3113                  * Steal away the file pointer from dfd and stuff it into indx.
3114                  */
3115                 newfde = &fdp->fd_ofiles[indx];
3116                 oldfde = &fdp->fd_ofiles[dfd];
3117 #ifdef CAPABILITIES
3118                 seqc_write_begin(&newfde->fde_seqc);
3119 #endif
3120                 memcpy(newfde, oldfde, fde_change_size);
3121                 oldfde->fde_file = NULL;
3122                 fdunused(fdp, dfd);
3123 #ifdef CAPABILITIES
3124                 seqc_write_end(&newfde->fde_seqc);
3125 #endif
3126                 break;
3127         }
3128         FILEDESC_XUNLOCK(fdp);
3129         *indxp = indx;
3130         return (0);
3131 }
3132
3133 /*
3134  * This sysctl determines if we will allow a process to chroot(2) if it
3135  * has a directory open:
3136  *      0: disallowed for all processes.
3137  *      1: allowed for processes that were not already chroot(2)'ed.
3138  *      2: allowed for all processes.
3139  */
3140
3141 static int chroot_allow_open_directories = 1;
3142
3143 SYSCTL_INT(_kern, OID_AUTO, chroot_allow_open_directories, CTLFLAG_RW,
3144     &chroot_allow_open_directories, 0,
3145     "Allow a process to chroot(2) if it has a directory open");
3146
3147 /*
3148  * Helper function for raised chroot(2) security function:  Refuse if
3149  * any filedescriptors are open directories.
3150  */
3151 static int
3152 chroot_refuse_vdir_fds(struct filedesc *fdp)
3153 {
3154         struct vnode *vp;
3155         struct file *fp;
3156         int fd;
3157
3158         FILEDESC_LOCK_ASSERT(fdp);
3159
3160         for (fd = 0; fd <= fdp->fd_lastfile; fd++) {
3161                 fp = fget_locked(fdp, fd);
3162                 if (fp == NULL)
3163                         continue;
3164                 if (fp->f_type == DTYPE_VNODE) {
3165                         vp = fp->f_vnode;
3166                         if (vp->v_type == VDIR)
3167                                 return (EPERM);
3168                 }
3169         }
3170         return (0);
3171 }
3172
3173 /*
3174  * Common routine for kern_chroot() and jail_attach().  The caller is
3175  * responsible for invoking priv_check() and mac_vnode_check_chroot() to
3176  * authorize this operation.
3177  */
3178 int
3179 pwd_chroot(struct thread *td, struct vnode *vp)
3180 {
3181         struct filedesc *fdp;
3182         struct vnode *oldvp;
3183         int error;
3184
3185         fdp = td->td_proc->p_fd;
3186         FILEDESC_XLOCK(fdp);
3187         if (chroot_allow_open_directories == 0 ||
3188             (chroot_allow_open_directories == 1 && fdp->fd_rdir != rootvnode)) {
3189                 error = chroot_refuse_vdir_fds(fdp);
3190                 if (error != 0) {
3191                         FILEDESC_XUNLOCK(fdp);
3192                         return (error);
3193                 }
3194         }
3195         oldvp = fdp->fd_rdir;
3196         vrefact(vp);
3197         fdp->fd_rdir = vp;
3198         if (fdp->fd_jdir == NULL) {
3199                 vrefact(vp);
3200                 fdp->fd_jdir = vp;
3201         }
3202         FILEDESC_XUNLOCK(fdp);
3203         vrele(oldvp);
3204         return (0);
3205 }
3206
3207 void
3208 pwd_chdir(struct thread *td, struct vnode *vp)
3209 {
3210         struct filedesc *fdp;
3211         struct vnode *oldvp;
3212
3213         fdp = td->td_proc->p_fd;
3214         FILEDESC_XLOCK(fdp);
3215         VNASSERT(vp->v_usecount > 0, vp,
3216             ("chdir to a vnode with zero usecount"));
3217         oldvp = fdp->fd_cdir;
3218         fdp->fd_cdir = vp;
3219         FILEDESC_XUNLOCK(fdp);
3220         vrele(oldvp);
3221 }
3222
3223 /*
3224  * Scan all active processes and prisons to see if any of them have a current
3225  * or root directory of `olddp'. If so, replace them with the new mount point.
3226  */
3227 void
3228 mountcheckdirs(struct vnode *olddp, struct vnode *newdp)
3229 {
3230         struct filedesc *fdp;
3231         struct prison *pr;
3232         struct proc *p;
3233         int nrele;
3234
3235         if (vrefcnt(olddp) == 1)
3236                 return;
3237         nrele = 0;
3238         sx_slock(&allproc_lock);
3239         FOREACH_PROC_IN_SYSTEM(p) {
3240                 PROC_LOCK(p);
3241                 fdp = fdhold(p);
3242                 PROC_UNLOCK(p);
3243                 if (fdp == NULL)
3244                         continue;
3245                 FILEDESC_XLOCK(fdp);
3246                 if (fdp->fd_cdir == olddp) {
3247                         vrefact(newdp);
3248                         fdp->fd_cdir = newdp;
3249                         nrele++;
3250                 }
3251                 if (fdp->fd_rdir == olddp) {
3252                         vrefact(newdp);
3253                         fdp->fd_rdir = newdp;
3254                         nrele++;
3255                 }
3256                 if (fdp->fd_jdir == olddp) {
3257                         vrefact(newdp);
3258                         fdp->fd_jdir = newdp;
3259                         nrele++;
3260                 }
3261                 FILEDESC_XUNLOCK(fdp);
3262                 fddrop(fdp);
3263         }
3264         sx_sunlock(&allproc_lock);
3265         if (rootvnode == olddp) {
3266                 vrefact(newdp);
3267                 rootvnode = newdp;
3268                 nrele++;
3269         }
3270         mtx_lock(&prison0.pr_mtx);
3271         if (prison0.pr_root == olddp) {
3272                 vrefact(newdp);
3273                 prison0.pr_root = newdp;
3274                 nrele++;
3275         }
3276         mtx_unlock(&prison0.pr_mtx);
3277         sx_slock(&allprison_lock);
3278         TAILQ_FOREACH(pr, &allprison, pr_list) {
3279                 mtx_lock(&pr->pr_mtx);
3280                 if (pr->pr_root == olddp) {
3281                         vrefact(newdp);
3282                         pr->pr_root = newdp;
3283                         nrele++;
3284                 }
3285                 mtx_unlock(&pr->pr_mtx);
3286         }
3287         sx_sunlock(&allprison_lock);
3288         while (nrele--)
3289                 vrele(olddp);
3290 }
3291
3292 struct filedesc_to_leader *
3293 filedesc_to_leader_alloc(struct filedesc_to_leader *old, struct filedesc *fdp, struct proc *leader)
3294 {
3295         struct filedesc_to_leader *fdtol;
3296
3297         fdtol = malloc(sizeof(struct filedesc_to_leader),
3298             M_FILEDESC_TO_LEADER, M_WAITOK);
3299         fdtol->fdl_refcount = 1;
3300         fdtol->fdl_holdcount = 0;
3301         fdtol->fdl_wakeup = 0;
3302         fdtol->fdl_leader = leader;
3303         if (old != NULL) {
3304                 FILEDESC_XLOCK(fdp);
3305                 fdtol->fdl_next = old->fdl_next;
3306                 fdtol->fdl_prev = old;
3307                 old->fdl_next = fdtol;
3308                 fdtol->fdl_next->fdl_prev = fdtol;
3309                 FILEDESC_XUNLOCK(fdp);
3310         } else {
3311                 fdtol->fdl_next = fdtol;
3312                 fdtol->fdl_prev = fdtol;
3313         }
3314         return (fdtol);
3315 }
3316
3317 static int
3318 sysctl_kern_proc_nfds(SYSCTL_HANDLER_ARGS)
3319 {
3320         struct filedesc *fdp;
3321         int i, count, slots;
3322
3323         if (*(int *)arg1 != 0)
3324                 return (EINVAL);
3325
3326         fdp = curproc->p_fd;
3327         count = 0;
3328         FILEDESC_SLOCK(fdp);
3329         slots = NDSLOTS(fdp->fd_lastfile + 1);
3330         for (i = 0; i < slots; i++)
3331                 count += bitcountl(fdp->fd_map[i]);
3332         FILEDESC_SUNLOCK(fdp);
3333
3334         return (SYSCTL_OUT(req, &count, sizeof(count)));
3335 }
3336
3337 static SYSCTL_NODE(_kern_proc, KERN_PROC_NFDS, nfds,
3338     CTLFLAG_RD|CTLFLAG_CAPRD|CTLFLAG_MPSAFE, sysctl_kern_proc_nfds,
3339     "Number of open file descriptors");
3340
3341 /*
3342  * Get file structures globally.
3343  */
3344 static int
3345 sysctl_kern_file(SYSCTL_HANDLER_ARGS)
3346 {
3347         struct xfile xf;
3348         struct filedesc *fdp;
3349         struct file *fp;
3350         struct proc *p;
3351         int error, n;
3352
3353         error = sysctl_wire_old_buffer(req, 0);
3354         if (error != 0)
3355                 return (error);
3356         if (req->oldptr == NULL) {
3357                 n = 0;
3358                 sx_slock(&allproc_lock);
3359                 FOREACH_PROC_IN_SYSTEM(p) {
3360                         PROC_LOCK(p);
3361                         if (p->p_state == PRS_NEW) {
3362                                 PROC_UNLOCK(p);
3363                                 continue;
3364                         }
3365                         fdp = fdhold(p);
3366                         PROC_UNLOCK(p);
3367                         if (fdp == NULL)
3368                                 continue;
3369                         /* overestimates sparse tables. */
3370                         if (fdp->fd_lastfile > 0)
3371                                 n += fdp->fd_lastfile;
3372                         fddrop(fdp);
3373                 }
3374                 sx_sunlock(&allproc_lock);
3375                 return (SYSCTL_OUT(req, 0, n * sizeof(xf)));
3376         }
3377         error = 0;
3378         bzero(&xf, sizeof(xf));
3379         xf.xf_size = sizeof(xf);
3380         sx_slock(&allproc_lock);
3381         FOREACH_PROC_IN_SYSTEM(p) {
3382                 PROC_LOCK(p);
3383                 if (p->p_state == PRS_NEW) {
3384                         PROC_UNLOCK(p);
3385                         continue;
3386                 }
3387                 if (p_cansee(req->td, p) != 0) {
3388                         PROC_UNLOCK(p);
3389                         continue;
3390                 }
3391                 xf.xf_pid = p->p_pid;
3392                 xf.xf_uid = p->p_ucred->cr_uid;
3393                 fdp = fdhold(p);
3394                 PROC_UNLOCK(p);
3395                 if (fdp == NULL)
3396                         continue;
3397                 FILEDESC_SLOCK(fdp);
3398                 for (n = 0; fdp->fd_refcnt > 0 && n <= fdp->fd_lastfile; ++n) {
3399                         if ((fp = fdp->fd_ofiles[n].fde_file) == NULL)
3400                                 continue;
3401                         xf.xf_fd = n;
3402                         xf.xf_file = (uintptr_t)fp;
3403                         xf.xf_data = (uintptr_t)fp->f_data;
3404                         xf.xf_vnode = (uintptr_t)fp->f_vnode;
3405                         xf.xf_type = (uintptr_t)fp->f_type;
3406                         xf.xf_count = fp->f_count;
3407                         xf.xf_msgcount = 0;
3408                         xf.xf_offset = foffset_get(fp);
3409                         xf.xf_flag = fp->f_flag;
3410                         error = SYSCTL_OUT(req, &xf, sizeof(xf));
3411                         if (error)
3412                                 break;
3413                 }
3414                 FILEDESC_SUNLOCK(fdp);
3415                 fddrop(fdp);
3416                 if (error)
3417                         break;
3418         }
3419         sx_sunlock(&allproc_lock);
3420         return (error);
3421 }
3422
3423 SYSCTL_PROC(_kern, KERN_FILE, file, CTLTYPE_OPAQUE|CTLFLAG_RD|CTLFLAG_MPSAFE,
3424     0, 0, sysctl_kern_file, "S,xfile", "Entire file table");
3425
3426 #ifdef KINFO_FILE_SIZE
3427 CTASSERT(sizeof(struct kinfo_file) == KINFO_FILE_SIZE);
3428 #endif
3429
3430 static int
3431 xlate_fflags(int fflags)
3432 {
3433         static const struct {
3434                 int     fflag;
3435                 int     kf_fflag;
3436         } fflags_table[] = {
3437                 { FAPPEND, KF_FLAG_APPEND },
3438                 { FASYNC, KF_FLAG_ASYNC },
3439                 { FFSYNC, KF_FLAG_FSYNC },
3440                 { FHASLOCK, KF_FLAG_HASLOCK },
3441                 { FNONBLOCK, KF_FLAG_NONBLOCK },
3442                 { FREAD, KF_FLAG_READ },
3443                 { FWRITE, KF_FLAG_WRITE },
3444                 { O_CREAT, KF_FLAG_CREAT },
3445                 { O_DIRECT, KF_FLAG_DIRECT },
3446                 { O_EXCL, KF_FLAG_EXCL },
3447                 { O_EXEC, KF_FLAG_EXEC },
3448                 { O_EXLOCK, KF_FLAG_EXLOCK },
3449                 { O_NOFOLLOW, KF_FLAG_NOFOLLOW },
3450                 { O_SHLOCK, KF_FLAG_SHLOCK },
3451                 { O_TRUNC, KF_FLAG_TRUNC }
3452         };
3453         unsigned int i;
3454         int kflags;
3455
3456         kflags = 0;
3457         for (i = 0; i < nitems(fflags_table); i++)
3458                 if (fflags & fflags_table[i].fflag)
3459                         kflags |=  fflags_table[i].kf_fflag;
3460         return (kflags);
3461 }
3462
3463 /* Trim unused data from kf_path by truncating the structure size. */
3464 void
3465 pack_kinfo(struct kinfo_file *kif)
3466 {
3467
3468         kif->kf_structsize = offsetof(struct kinfo_file, kf_path) +
3469             strlen(kif->kf_path) + 1;
3470         kif->kf_structsize = roundup(kif->kf_structsize, sizeof(uint64_t));
3471 }
3472
3473 static void
3474 export_file_to_kinfo(struct file *fp, int fd, cap_rights_t *rightsp,
3475     struct kinfo_file *kif, struct filedesc *fdp, int flags)
3476 {
3477         int error;
3478
3479         bzero(kif, sizeof(*kif));
3480
3481         /* Set a default type to allow for empty fill_kinfo() methods. */
3482         kif->kf_type = KF_TYPE_UNKNOWN;
3483         kif->kf_flags = xlate_fflags(fp->f_flag);
3484         if (rightsp != NULL)
3485                 kif->kf_cap_rights = *rightsp;
3486         else
3487                 cap_rights_init(&kif->kf_cap_rights);
3488         kif->kf_fd = fd;
3489         kif->kf_ref_count = fp->f_count;
3490         kif->kf_offset = foffset_get(fp);
3491
3492         /*
3493          * This may drop the filedesc lock, so the 'fp' cannot be
3494          * accessed after this call.
3495          */
3496         error = fo_fill_kinfo(fp, kif, fdp);
3497         if (error == 0)
3498                 kif->kf_status |= KF_ATTR_VALID;
3499         if ((flags & KERN_FILEDESC_PACK_KINFO) != 0)
3500                 pack_kinfo(kif);
3501         else
3502                 kif->kf_structsize = roundup2(sizeof(*kif), sizeof(uint64_t));
3503 }
3504
3505 static void
3506 export_vnode_to_kinfo(struct vnode *vp, int fd, int fflags,
3507     struct kinfo_file *kif, int flags)
3508 {
3509         int error;
3510
3511         bzero(kif, sizeof(*kif));
3512
3513         kif->kf_type = KF_TYPE_VNODE;
3514         error = vn_fill_kinfo_vnode(vp, kif);
3515         if (error == 0)
3516                 kif->kf_status |= KF_ATTR_VALID;
3517         kif->kf_flags = xlate_fflags(fflags);
3518         cap_rights_init(&kif->kf_cap_rights);
3519         kif->kf_fd = fd;
3520         kif->kf_ref_count = -1;
3521         kif->kf_offset = -1;
3522         if ((flags & KERN_FILEDESC_PACK_KINFO) != 0)
3523                 pack_kinfo(kif);
3524         else
3525                 kif->kf_structsize = roundup2(sizeof(*kif), sizeof(uint64_t));
3526         vrele(vp);
3527 }
3528
3529 struct export_fd_buf {
3530         struct filedesc         *fdp;
3531         struct sbuf             *sb;
3532         ssize_t                 remainder;
3533         struct kinfo_file       kif;
3534         int                     flags;
3535 };
3536
3537 static int
3538 export_kinfo_to_sb(struct export_fd_buf *efbuf)
3539 {
3540         struct kinfo_file *kif;
3541
3542         kif = &efbuf->kif;
3543         if (efbuf->remainder != -1) {
3544                 if (efbuf->remainder < kif->kf_structsize) {
3545                         /* Terminate export. */
3546                         efbuf->remainder = 0;
3547                         return (0);
3548                 }
3549                 efbuf->remainder -= kif->kf_structsize;
3550         }
3551         return (sbuf_bcat(efbuf->sb, kif, kif->kf_structsize) == 0 ? 0 : ENOMEM);
3552 }
3553
3554 static int
3555 export_file_to_sb(struct file *fp, int fd, cap_rights_t *rightsp,
3556     struct export_fd_buf *efbuf)
3557 {
3558         int error;
3559
3560         if (efbuf->remainder == 0)
3561                 return (0);
3562         export_file_to_kinfo(fp, fd, rightsp, &efbuf->kif, efbuf->fdp,
3563             efbuf->flags);
3564         FILEDESC_SUNLOCK(efbuf->fdp);
3565         error = export_kinfo_to_sb(efbuf);
3566         FILEDESC_SLOCK(efbuf->fdp);
3567         return (error);
3568 }
3569
3570 static int
3571 export_vnode_to_sb(struct vnode *vp, int fd, int fflags,
3572     struct export_fd_buf *efbuf)
3573 {
3574         int error;
3575
3576         if (efbuf->remainder == 0)
3577                 return (0);
3578         if (efbuf->fdp != NULL)
3579                 FILEDESC_SUNLOCK(efbuf->fdp);
3580         export_vnode_to_kinfo(vp, fd, fflags, &efbuf->kif, efbuf->flags);
3581         error = export_kinfo_to_sb(efbuf);
3582         if (efbuf->fdp != NULL)
3583                 FILEDESC_SLOCK(efbuf->fdp);
3584         return (error);
3585 }
3586
3587 /*
3588  * Store a process file descriptor information to sbuf.
3589  *
3590  * Takes a locked proc as argument, and returns with the proc unlocked.
3591  */
3592 int
3593 kern_proc_filedesc_out(struct proc *p,  struct sbuf *sb, ssize_t maxlen,
3594     int flags)
3595 {
3596         struct file *fp;
3597         struct filedesc *fdp;
3598         struct export_fd_buf *efbuf;
3599         struct vnode *cttyvp, *textvp, *tracevp;
3600         int error, i;
3601         cap_rights_t rights;
3602
3603         PROC_LOCK_ASSERT(p, MA_OWNED);
3604
3605         /* ktrace vnode */
3606         tracevp = p->p_tracevp;
3607         if (tracevp != NULL)
3608                 vrefact(tracevp);
3609         /* text vnode */
3610         textvp = p->p_textvp;
3611         if (textvp != NULL)
3612                 vrefact(textvp);
3613         /* Controlling tty. */
3614         cttyvp = NULL;
3615         if (p->p_pgrp != NULL && p->p_pgrp->pg_session != NULL) {
3616                 cttyvp = p->p_pgrp->pg_session->s_ttyvp;
3617                 if (cttyvp != NULL)
3618                         vrefact(cttyvp);
3619         }
3620         fdp = fdhold(p);
3621         PROC_UNLOCK(p);
3622         efbuf = malloc(sizeof(*efbuf), M_TEMP, M_WAITOK);
3623         efbuf->fdp = NULL;
3624         efbuf->sb = sb;
3625         efbuf->remainder = maxlen;
3626         efbuf->flags = flags;
3627         if (tracevp != NULL)
3628                 export_vnode_to_sb(tracevp, KF_FD_TYPE_TRACE, FREAD | FWRITE,
3629                     efbuf);
3630         if (textvp != NULL)
3631                 export_vnode_to_sb(textvp, KF_FD_TYPE_TEXT, FREAD, efbuf);
3632         if (cttyvp != NULL)
3633                 export_vnode_to_sb(cttyvp, KF_FD_TYPE_CTTY, FREAD | FWRITE,
3634                     efbuf);
3635         error = 0;
3636         if (fdp == NULL)
3637                 goto fail;
3638         efbuf->fdp = fdp;
3639         FILEDESC_SLOCK(fdp);
3640         /* working directory */
3641         if (fdp->fd_cdir != NULL) {
3642                 vrefact(fdp->fd_cdir);
3643                 export_vnode_to_sb(fdp->fd_cdir, KF_FD_TYPE_CWD, FREAD, efbuf);
3644         }
3645         /* root directory */
3646         if (fdp->fd_rdir != NULL) {
3647                 vrefact(fdp->fd_rdir);
3648                 export_vnode_to_sb(fdp->fd_rdir, KF_FD_TYPE_ROOT, FREAD, efbuf);
3649         }
3650         /* jail directory */
3651         if (fdp->fd_jdir != NULL) {
3652                 vrefact(fdp->fd_jdir);
3653                 export_vnode_to_sb(fdp->fd_jdir, KF_FD_TYPE_JAIL, FREAD, efbuf);
3654         }
3655         for (i = 0; fdp->fd_refcnt > 0 && i <= fdp->fd_lastfile; i++) {
3656                 if ((fp = fdp->fd_ofiles[i].fde_file) == NULL)
3657                         continue;
3658 #ifdef CAPABILITIES
3659                 rights = *cap_rights(fdp, i);
3660 #else /* !CAPABILITIES */
3661                 rights = cap_no_rights;
3662 #endif
3663                 /*
3664                  * Create sysctl entry.  It is OK to drop the filedesc
3665                  * lock inside of export_file_to_sb() as we will
3666                  * re-validate and re-evaluate its properties when the
3667                  * loop continues.
3668                  */
3669                 error = export_file_to_sb(fp, i, &rights, efbuf);
3670                 if (error != 0 || efbuf->remainder == 0)
3671                         break;
3672         }
3673         FILEDESC_SUNLOCK(fdp);
3674         fddrop(fdp);
3675 fail:
3676         free(efbuf, M_TEMP);
3677         return (error);
3678 }
3679
3680 #define FILEDESC_SBUF_SIZE      (sizeof(struct kinfo_file) * 5)
3681
3682 /*
3683  * Get per-process file descriptors for use by procstat(1), et al.
3684  */
3685 static int
3686 sysctl_kern_proc_filedesc(SYSCTL_HANDLER_ARGS)
3687 {
3688         struct sbuf sb;
3689         struct proc *p;
3690         ssize_t maxlen;
3691         int error, error2, *name;
3692
3693         name = (int *)arg1;
3694
3695         sbuf_new_for_sysctl(&sb, NULL, FILEDESC_SBUF_SIZE, req);
3696         sbuf_clear_flags(&sb, SBUF_INCLUDENUL);
3697         error = pget((pid_t)name[0], PGET_CANDEBUG | PGET_NOTWEXIT, &p);
3698         if (error != 0) {
3699                 sbuf_delete(&sb);
3700                 return (error);
3701         }
3702         maxlen = req->oldptr != NULL ? req->oldlen : -1;
3703         error = kern_proc_filedesc_out(p, &sb, maxlen,
3704             KERN_FILEDESC_PACK_KINFO);
3705         error2 = sbuf_finish(&sb);
3706         sbuf_delete(&sb);
3707         return (error != 0 ? error : error2);
3708 }
3709
3710 #ifdef COMPAT_FREEBSD7
3711 #ifdef KINFO_OFILE_SIZE
3712 CTASSERT(sizeof(struct kinfo_ofile) == KINFO_OFILE_SIZE);
3713 #endif
3714
3715 static void
3716 kinfo_to_okinfo(struct kinfo_file *kif, struct kinfo_ofile *okif)
3717 {
3718
3719         okif->kf_structsize = sizeof(*okif);
3720         okif->kf_type = kif->kf_type;
3721         okif->kf_fd = kif->kf_fd;
3722         okif->kf_ref_count = kif->kf_ref_count;
3723         okif->kf_flags = kif->kf_flags & (KF_FLAG_READ | KF_FLAG_WRITE |
3724             KF_FLAG_APPEND | KF_FLAG_ASYNC | KF_FLAG_FSYNC | KF_FLAG_NONBLOCK |
3725             KF_FLAG_DIRECT | KF_FLAG_HASLOCK);
3726         okif->kf_offset = kif->kf_offset;
3727         if (kif->kf_type == KF_TYPE_VNODE)
3728                 okif->kf_vnode_type = kif->kf_un.kf_file.kf_file_type;
3729         else
3730                 okif->kf_vnode_type = KF_VTYPE_VNON;
3731         strlcpy(okif->kf_path, kif->kf_path, sizeof(okif->kf_path));
3732         if (kif->kf_type == KF_TYPE_SOCKET) {
3733                 okif->kf_sock_domain = kif->kf_un.kf_sock.kf_sock_domain0;
3734                 okif->kf_sock_type = kif->kf_un.kf_sock.kf_sock_type0;
3735                 okif->kf_sock_protocol = kif->kf_un.kf_sock.kf_sock_protocol0;
3736                 okif->kf_sa_local = kif->kf_un.kf_sock.kf_sa_local;
3737                 okif->kf_sa_peer = kif->kf_un.kf_sock.kf_sa_peer;
3738         } else {
3739                 okif->kf_sa_local.ss_family = AF_UNSPEC;
3740                 okif->kf_sa_peer.ss_family = AF_UNSPEC;
3741         }
3742 }
3743
3744 static int
3745 export_vnode_for_osysctl(struct vnode *vp, int type, struct kinfo_file *kif,
3746     struct kinfo_ofile *okif, struct filedesc *fdp, struct sysctl_req *req)
3747 {
3748         int error;
3749
3750         vrefact(vp);
3751         FILEDESC_SUNLOCK(fdp);
3752         export_vnode_to_kinfo(vp, type, 0, kif, KERN_FILEDESC_PACK_KINFO);
3753         kinfo_to_okinfo(kif, okif);
3754         error = SYSCTL_OUT(req, okif, sizeof(*okif));
3755         FILEDESC_SLOCK(fdp);
3756         return (error);
3757 }
3758
3759 /*
3760  * Get per-process file descriptors for use by procstat(1), et al.
3761  */
3762 static int
3763 sysctl_kern_proc_ofiledesc(SYSCTL_HANDLER_ARGS)
3764 {
3765         struct kinfo_ofile *okif;
3766         struct kinfo_file *kif;
3767         struct filedesc *fdp;
3768         int error, i, *name;
3769         struct file *fp;
3770         struct proc *p;
3771
3772         name = (int *)arg1;
3773         error = pget((pid_t)name[0], PGET_CANDEBUG | PGET_NOTWEXIT, &p);
3774         if (error != 0)
3775                 return (error);
3776         fdp = fdhold(p);
3777         PROC_UNLOCK(p);
3778         if (fdp == NULL)
3779                 return (ENOENT);
3780         kif = malloc(sizeof(*kif), M_TEMP, M_WAITOK);
3781         okif = malloc(sizeof(*okif), M_TEMP, M_WAITOK);
3782         FILEDESC_SLOCK(fdp);
3783         if (fdp->fd_cdir != NULL)
3784                 export_vnode_for_osysctl(fdp->fd_cdir, KF_FD_TYPE_CWD, kif,
3785                     okif, fdp, req);
3786         if (fdp->fd_rdir != NULL)
3787                 export_vnode_for_osysctl(fdp->fd_rdir, KF_FD_TYPE_ROOT, kif,
3788                     okif, fdp, req);
3789         if (fdp->fd_jdir != NULL)
3790                 export_vnode_for_osysctl(fdp->fd_jdir, KF_FD_TYPE_JAIL, kif,
3791                     okif, fdp, req);
3792         for (i = 0; fdp->fd_refcnt > 0 && i <= fdp->fd_lastfile; i++) {
3793                 if ((fp = fdp->fd_ofiles[i].fde_file) == NULL)
3794                         continue;
3795                 export_file_to_kinfo(fp, i, NULL, kif, fdp,
3796                     KERN_FILEDESC_PACK_KINFO);
3797                 FILEDESC_SUNLOCK(fdp);
3798                 kinfo_to_okinfo(kif, okif);
3799                 error = SYSCTL_OUT(req, okif, sizeof(*okif));
3800                 FILEDESC_SLOCK(fdp);
3801                 if (error)
3802                         break;
3803         }
3804         FILEDESC_SUNLOCK(fdp);
3805         fddrop(fdp);
3806         free(kif, M_TEMP);
3807         free(okif, M_TEMP);
3808         return (0);
3809 }
3810
3811 static SYSCTL_NODE(_kern_proc, KERN_PROC_OFILEDESC, ofiledesc,
3812     CTLFLAG_RD|CTLFLAG_MPSAFE, sysctl_kern_proc_ofiledesc,
3813     "Process ofiledesc entries");
3814 #endif  /* COMPAT_FREEBSD7 */
3815
3816 int
3817 vntype_to_kinfo(int vtype)
3818 {
3819         struct {
3820                 int     vtype;
3821                 int     kf_vtype;
3822         } vtypes_table[] = {
3823                 { VBAD, KF_VTYPE_VBAD },
3824                 { VBLK, KF_VTYPE_VBLK },
3825                 { VCHR, KF_VTYPE_VCHR },
3826                 { VDIR, KF_VTYPE_VDIR },
3827                 { VFIFO, KF_VTYPE_VFIFO },
3828                 { VLNK, KF_VTYPE_VLNK },
3829                 { VNON, KF_VTYPE_VNON },
3830                 { VREG, KF_VTYPE_VREG },
3831                 { VSOCK, KF_VTYPE_VSOCK }
3832         };
3833         unsigned int i;
3834
3835         /*
3836          * Perform vtype translation.
3837          */
3838         for (i = 0; i < nitems(vtypes_table); i++)
3839                 if (vtypes_table[i].vtype == vtype)
3840                         return (vtypes_table[i].kf_vtype);
3841
3842         return (KF_VTYPE_UNKNOWN);
3843 }
3844
3845 static SYSCTL_NODE(_kern_proc, KERN_PROC_FILEDESC, filedesc,
3846     CTLFLAG_RD|CTLFLAG_MPSAFE, sysctl_kern_proc_filedesc,
3847     "Process filedesc entries");
3848
3849 /*
3850  * Store a process current working directory information to sbuf.
3851  *
3852  * Takes a locked proc as argument, and returns with the proc unlocked.
3853  */
3854 int
3855 kern_proc_cwd_out(struct proc *p,  struct sbuf *sb, ssize_t maxlen)
3856 {
3857         struct filedesc *fdp;
3858         struct export_fd_buf *efbuf;
3859         int error;
3860
3861         PROC_LOCK_ASSERT(p, MA_OWNED);
3862
3863         fdp = fdhold(p);
3864         PROC_UNLOCK(p);
3865         if (fdp == NULL)
3866                 return (EINVAL);
3867
3868         efbuf = malloc(sizeof(*efbuf), M_TEMP, M_WAITOK);
3869         efbuf->fdp = fdp;
3870         efbuf->sb = sb;
3871         efbuf->remainder = maxlen;
3872
3873         FILEDESC_SLOCK(fdp);
3874         if (fdp->fd_cdir == NULL)
3875                 error = EINVAL;
3876         else {
3877                 vrefact(fdp->fd_cdir);
3878                 error = export_vnode_to_sb(fdp->fd_cdir, KF_FD_TYPE_CWD,
3879                     FREAD, efbuf);
3880         }
3881         FILEDESC_SUNLOCK(fdp);
3882         fddrop(fdp);
3883         free(efbuf, M_TEMP);
3884         return (error);
3885 }
3886
3887 /*
3888  * Get per-process current working directory.
3889  */
3890 static int
3891 sysctl_kern_proc_cwd(SYSCTL_HANDLER_ARGS)
3892 {
3893         struct sbuf sb;
3894         struct proc *p;
3895         ssize_t maxlen;
3896         int error, error2, *name;
3897
3898         name = (int *)arg1;
3899
3900         sbuf_new_for_sysctl(&sb, NULL, sizeof(struct kinfo_file), req);
3901         sbuf_clear_flags(&sb, SBUF_INCLUDENUL);
3902         error = pget((pid_t)name[0], PGET_CANDEBUG | PGET_NOTWEXIT, &p);
3903         if (error != 0) {
3904                 sbuf_delete(&sb);
3905                 return (error);
3906         }
3907         maxlen = req->oldptr != NULL ? req->oldlen : -1;
3908         error = kern_proc_cwd_out(p, &sb, maxlen);
3909         error2 = sbuf_finish(&sb);
3910         sbuf_delete(&sb);
3911         return (error != 0 ? error : error2);
3912 }
3913
3914 static SYSCTL_NODE(_kern_proc, KERN_PROC_CWD, cwd, CTLFLAG_RD|CTLFLAG_MPSAFE,
3915     sysctl_kern_proc_cwd, "Process current working directory");
3916
3917 #ifdef DDB
3918 /*
3919  * For the purposes of debugging, generate a human-readable string for the
3920  * file type.
3921  */
3922 static const char *
3923 file_type_to_name(short type)
3924 {
3925
3926         switch (type) {
3927         case 0:
3928                 return ("zero");
3929         case DTYPE_VNODE:
3930                 return ("vnode");
3931         case DTYPE_SOCKET:
3932                 return ("socket");
3933         case DTYPE_PIPE:
3934                 return ("pipe");
3935         case DTYPE_FIFO:
3936                 return ("fifo");
3937         case DTYPE_KQUEUE:
3938                 return ("kqueue");
3939         case DTYPE_CRYPTO:
3940                 return ("crypto");
3941         case DTYPE_MQUEUE:
3942                 return ("mqueue");
3943         case DTYPE_SHM:
3944                 return ("shm");
3945         case DTYPE_SEM:
3946                 return ("ksem");
3947         case DTYPE_PTS:
3948                 return ("pts");
3949         case DTYPE_DEV:
3950                 return ("dev");
3951         case DTYPE_PROCDESC:
3952                 return ("proc");
3953         case DTYPE_LINUXEFD:
3954                 return ("levent");
3955         case DTYPE_LINUXTFD:
3956                 return ("ltimer");
3957         default:
3958                 return ("unkn");
3959         }
3960 }
3961
3962 /*
3963  * For the purposes of debugging, identify a process (if any, perhaps one of
3964  * many) that references the passed file in its file descriptor array. Return
3965  * NULL if none.
3966  */
3967 static struct proc *
3968 file_to_first_proc(struct file *fp)
3969 {
3970         struct filedesc *fdp;
3971         struct proc *p;
3972         int n;
3973
3974         FOREACH_PROC_IN_SYSTEM(p) {
3975                 if (p->p_state == PRS_NEW)
3976                         continue;
3977                 fdp = p->p_fd;
3978                 if (fdp == NULL)
3979                         continue;
3980                 for (n = 0; n <= fdp->fd_lastfile; n++) {
3981                         if (fp == fdp->fd_ofiles[n].fde_file)
3982                                 return (p);
3983                 }
3984         }
3985         return (NULL);
3986 }
3987
3988 static void
3989 db_print_file(struct file *fp, int header)
3990 {
3991 #define XPTRWIDTH ((int)howmany(sizeof(void *) * NBBY, 4))
3992         struct proc *p;
3993
3994         if (header)
3995                 db_printf("%*s %6s %*s %8s %4s %5s %6s %*s %5s %s\n",
3996                     XPTRWIDTH, "File", "Type", XPTRWIDTH, "Data", "Flag",
3997                     "GCFl", "Count", "MCount", XPTRWIDTH, "Vnode", "FPID",
3998                     "FCmd");
3999         p = file_to_first_proc(fp);
4000         db_printf("%*p %6s %*p %08x %04x %5d %6d %*p %5d %s\n", XPTRWIDTH,
4001             fp, file_type_to_name(fp->f_type), XPTRWIDTH, fp->f_data,
4002             fp->f_flag, 0, fp->f_count, 0, XPTRWIDTH, fp->f_vnode,
4003             p != NULL ? p->p_pid : -1, p != NULL ? p->p_comm : "-");
4004
4005 #undef XPTRWIDTH
4006 }
4007
4008 DB_SHOW_COMMAND(file, db_show_file)
4009 {
4010         struct file *fp;
4011
4012         if (!have_addr) {
4013                 db_printf("usage: show file <addr>\n");
4014                 return;
4015         }
4016         fp = (struct file *)addr;
4017         db_print_file(fp, 1);
4018 }
4019
4020 DB_SHOW_COMMAND(files, db_show_files)
4021 {
4022         struct filedesc *fdp;
4023         struct file *fp;
4024         struct proc *p;
4025         int header;
4026         int n;
4027
4028         header = 1;
4029         FOREACH_PROC_IN_SYSTEM(p) {
4030                 if (p->p_state == PRS_NEW)
4031                         continue;
4032                 if ((fdp = p->p_fd) == NULL)
4033                         continue;
4034                 for (n = 0; n <= fdp->fd_lastfile; ++n) {
4035                         if ((fp = fdp->fd_ofiles[n].fde_file) == NULL)
4036                                 continue;
4037                         db_print_file(fp, header);
4038                         header = 0;
4039                 }
4040         }
4041 }
4042 #endif
4043
4044 SYSCTL_INT(_kern, KERN_MAXFILESPERPROC, maxfilesperproc, CTLFLAG_RW,
4045     &maxfilesperproc, 0, "Maximum files allowed open per process");
4046
4047 SYSCTL_INT(_kern, KERN_MAXFILES, maxfiles, CTLFLAG_RW,
4048     &maxfiles, 0, "Maximum number of files");
4049
4050 SYSCTL_INT(_kern, OID_AUTO, openfiles, CTLFLAG_RD,
4051     &openfiles, 0, "System-wide number of open files");
4052
4053 /* ARGSUSED*/
4054 static void
4055 filelistinit(void *dummy)
4056 {
4057
4058         file_zone = uma_zcreate("Files", sizeof(struct file), NULL, NULL,
4059             NULL, NULL, UMA_ALIGN_PTR, UMA_ZONE_NOFREE);
4060         filedesc0_zone = uma_zcreate("filedesc0", sizeof(struct filedesc0),
4061             NULL, NULL, NULL, NULL, UMA_ALIGN_PTR, 0);
4062         mtx_init(&sigio_lock, "sigio lock", NULL, MTX_DEF);
4063 }
4064 SYSINIT(select, SI_SUB_LOCK, SI_ORDER_FIRST, filelistinit, NULL);
4065
4066 /*-------------------------------------------------------------------*/
4067
4068 static int
4069 badfo_readwrite(struct file *fp, struct uio *uio, struct ucred *active_cred,
4070     int flags, struct thread *td)
4071 {
4072
4073         return (EBADF);
4074 }
4075
4076 static int
4077 badfo_truncate(struct file *fp, off_t length, struct ucred *active_cred,
4078     struct thread *td)
4079 {
4080
4081         return (EINVAL);
4082 }
4083
4084 static int
4085 badfo_ioctl(struct file *fp, u_long com, void *data, struct ucred *active_cred,
4086     struct thread *td)
4087 {
4088
4089         return (EBADF);
4090 }
4091
4092 static int
4093 badfo_poll(struct file *fp, int events, struct ucred *active_cred,
4094     struct thread *td)
4095 {
4096
4097         return (0);
4098 }
4099
4100 static int
4101 badfo_kqfilter(struct file *fp, struct knote *kn)
4102 {
4103
4104         return (EBADF);
4105 }
4106
4107 static int
4108 badfo_stat(struct file *fp, struct stat *sb, struct ucred *active_cred,
4109     struct thread *td)
4110 {
4111
4112         return (EBADF);
4113 }
4114
4115 static int
4116 badfo_close(struct file *fp, struct thread *td)
4117 {
4118
4119         return (0);
4120 }
4121
4122 static int
4123 badfo_chmod(struct file *fp, mode_t mode, struct ucred *active_cred,
4124     struct thread *td)
4125 {
4126
4127         return (EBADF);
4128 }
4129
4130 static int
4131 badfo_chown(struct file *fp, uid_t uid, gid_t gid, struct ucred *active_cred,
4132     struct thread *td)
4133 {
4134
4135         return (EBADF);
4136 }
4137
4138 static int
4139 badfo_sendfile(struct file *fp, int sockfd, struct uio *hdr_uio,
4140     struct uio *trl_uio, off_t offset, size_t nbytes, off_t *sent, int flags,
4141     struct thread *td)
4142 {
4143
4144         return (EBADF);
4145 }
4146
4147 static int
4148 badfo_fill_kinfo(struct file *fp, struct kinfo_file *kif, struct filedesc *fdp)
4149 {
4150
4151         return (0);
4152 }
4153
4154 struct fileops badfileops = {
4155         .fo_read = badfo_readwrite,
4156         .fo_write = badfo_readwrite,
4157         .fo_truncate = badfo_truncate,
4158         .fo_ioctl = badfo_ioctl,
4159         .fo_poll = badfo_poll,
4160         .fo_kqfilter = badfo_kqfilter,
4161         .fo_stat = badfo_stat,
4162         .fo_close = badfo_close,
4163         .fo_chmod = badfo_chmod,
4164         .fo_chown = badfo_chown,
4165         .fo_sendfile = badfo_sendfile,
4166         .fo_fill_kinfo = badfo_fill_kinfo,
4167 };
4168
4169 int
4170 invfo_rdwr(struct file *fp, struct uio *uio, struct ucred *active_cred,
4171     int flags, struct thread *td)
4172 {
4173
4174         return (EOPNOTSUPP);
4175 }
4176
4177 int
4178 invfo_truncate(struct file *fp, off_t length, struct ucred *active_cred,
4179     struct thread *td)
4180 {
4181
4182         return (EINVAL);
4183 }
4184
4185 int
4186 invfo_ioctl(struct file *fp, u_long com, void *data,
4187     struct ucred *active_cred, struct thread *td)
4188 {
4189
4190         return (ENOTTY);
4191 }
4192
4193 int
4194 invfo_poll(struct file *fp, int events, struct ucred *active_cred,
4195     struct thread *td)
4196 {
4197
4198         return (poll_no_poll(events));
4199 }
4200
4201 int
4202 invfo_kqfilter(struct file *fp, struct knote *kn)
4203 {
4204
4205         return (EINVAL);
4206 }
4207
4208 int
4209 invfo_chmod(struct file *fp, mode_t mode, struct ucred *active_cred,
4210     struct thread *td)
4211 {
4212
4213         return (EINVAL);
4214 }
4215
4216 int
4217 invfo_chown(struct file *fp, uid_t uid, gid_t gid, struct ucred *active_cred,
4218     struct thread *td)
4219 {
4220
4221         return (EINVAL);
4222 }
4223
4224 int
4225 invfo_sendfile(struct file *fp, int sockfd, struct uio *hdr_uio,
4226     struct uio *trl_uio, off_t offset, size_t nbytes, off_t *sent, int flags,
4227     struct thread *td)
4228 {
4229
4230         return (EINVAL);
4231 }
4232
4233 /*-------------------------------------------------------------------*/
4234
4235 /*
4236  * File Descriptor pseudo-device driver (/dev/fd/).
4237  *
4238  * Opening minor device N dup()s the file (if any) connected to file
4239  * descriptor N belonging to the calling process.  Note that this driver
4240  * consists of only the ``open()'' routine, because all subsequent
4241  * references to this file will be direct to the other driver.
4242  *
4243  * XXX: we could give this one a cloning event handler if necessary.
4244  */
4245
4246 /* ARGSUSED */
4247 static int
4248 fdopen(struct cdev *dev, int mode, int type, struct thread *td)
4249 {
4250
4251         /*
4252          * XXX Kludge: set curthread->td_dupfd to contain the value of the
4253          * the file descriptor being sought for duplication. The error
4254          * return ensures that the vnode for this device will be released
4255          * by vn_open. Open will detect this special error and take the
4256          * actions in dupfdopen below. Other callers of vn_open or VOP_OPEN
4257          * will simply report the error.
4258          */
4259         td->td_dupfd = dev2unit(dev);
4260         return (ENODEV);
4261 }
4262
4263 static struct cdevsw fildesc_cdevsw = {
4264         .d_version =    D_VERSION,
4265         .d_open =       fdopen,
4266         .d_name =       "FD",
4267 };
4268
4269 static void
4270 fildesc_drvinit(void *unused)
4271 {
4272         struct cdev *dev;
4273
4274         dev = make_dev_credf(MAKEDEV_ETERNAL, &fildesc_cdevsw, 0, NULL,
4275             UID_ROOT, GID_WHEEL, 0666, "fd/0");
4276         make_dev_alias(dev, "stdin");
4277         dev = make_dev_credf(MAKEDEV_ETERNAL, &fildesc_cdevsw, 1, NULL,
4278             UID_ROOT, GID_WHEEL, 0666, "fd/1");
4279         make_dev_alias(dev, "stdout");
4280         dev = make_dev_credf(MAKEDEV_ETERNAL, &fildesc_cdevsw, 2, NULL,
4281             UID_ROOT, GID_WHEEL, 0666, "fd/2");
4282         make_dev_alias(dev, "stderr");
4283 }
4284
4285 SYSINIT(fildescdev, SI_SUB_DRIVERS, SI_ORDER_MIDDLE, fildesc_drvinit, NULL);