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