1 /*- 2 * SPDX-License-Identifier: BSD-3-Clause 3 * 4 * Copyright (c) 1989, 1993 5 * The Regents of the University of California. All rights reserved. 6 * 7 * This code is derived from software contributed 8 * to Berkeley by John Heidemann of the UCLA Ficus project. 9 * 10 * Source: * @(#)i405_init.c 2.10 92/04/27 UCLA Ficus project 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 37 #include <sys/cdefs.h> 38 __FBSDID("$FreeBSD$"); 39 40 #include <sys/param.h> 41 #include <sys/systm.h> 42 #include <sys/bio.h> 43 #include <sys/buf.h> 44 #include <sys/conf.h> 45 #include <sys/event.h> 46 #include <sys/kernel.h> 47 #include <sys/limits.h> 48 #include <sys/lock.h> 49 #include <sys/lockf.h> 50 #include <sys/malloc.h> 51 #include <sys/mount.h> 52 #include <sys/namei.h> 53 #include <sys/rwlock.h> 54 #include <sys/fcntl.h> 55 #include <sys/unistd.h> 56 #include <sys/vnode.h> 57 #include <sys/dirent.h> 58 #include <sys/poll.h> 59 60 #include <security/mac/mac_framework.h> 61 62 #include <vm/vm.h> 63 #include <vm/vm_object.h> 64 #include <vm/vm_extern.h> 65 #include <vm/pmap.h> 66 #include <vm/vm_map.h> 67 #include <vm/vm_page.h> 68 #include <vm/vm_pager.h> 69 #include <vm/vnode_pager.h> 70 71 static int vop_nolookup(struct vop_lookup_args *); 72 static int vop_norename(struct vop_rename_args *); 73 static int vop_nostrategy(struct vop_strategy_args *); 74 static int get_next_dirent(struct vnode *vp, struct dirent **dpp, 75 char *dirbuf, int dirbuflen, off_t *off, 76 char **cpos, int *len, int *eofflag, 77 struct thread *td); 78 static int dirent_exists(struct vnode *vp, const char *dirname, 79 struct thread *td); 80 81 #define DIRENT_MINSIZE (sizeof(struct dirent) - (MAXNAMLEN+1) + 4) 82 83 static int vop_stdis_text(struct vop_is_text_args *ap); 84 static int vop_stdunset_text(struct vop_unset_text_args *ap); 85 static int vop_stdadd_writecount(struct vop_add_writecount_args *ap); 86 static int vop_stdfdatasync(struct vop_fdatasync_args *ap); 87 static int vop_stdgetpages_async(struct vop_getpages_async_args *ap); 88 89 /* 90 * This vnode table stores what we want to do if the filesystem doesn't 91 * implement a particular VOP. 92 * 93 * If there is no specific entry here, we will return EOPNOTSUPP. 94 * 95 * Note that every filesystem has to implement either vop_access 96 * or vop_accessx; failing to do so will result in immediate crash 97 * due to stack overflow, as vop_stdaccess() calls vop_stdaccessx(), 98 * which calls vop_stdaccess() etc. 99 */ 100 101 struct vop_vector default_vnodeops = { 102 .vop_default = NULL, 103 .vop_bypass = VOP_EOPNOTSUPP, 104 105 .vop_access = vop_stdaccess, 106 .vop_accessx = vop_stdaccessx, 107 .vop_advise = vop_stdadvise, 108 .vop_advlock = vop_stdadvlock, 109 .vop_advlockasync = vop_stdadvlockasync, 110 .vop_advlockpurge = vop_stdadvlockpurge, 111 .vop_allocate = vop_stdallocate, 112 .vop_bmap = vop_stdbmap, 113 .vop_close = VOP_NULL, 114 .vop_fsync = VOP_NULL, 115 .vop_fdatasync = vop_stdfdatasync, 116 .vop_getpages = vop_stdgetpages, 117 .vop_getpages_async = vop_stdgetpages_async, 118 .vop_getwritemount = vop_stdgetwritemount, 119 .vop_inactive = VOP_NULL, 120 .vop_ioctl = VOP_ENOTTY, 121 .vop_kqfilter = vop_stdkqfilter, 122 .vop_islocked = vop_stdislocked, 123 .vop_lock1 = vop_stdlock, 124 .vop_lookup = vop_nolookup, 125 .vop_open = VOP_NULL, 126 .vop_pathconf = VOP_EINVAL, 127 .vop_poll = vop_nopoll, 128 .vop_putpages = vop_stdputpages, 129 .vop_readlink = VOP_EINVAL, 130 .vop_rename = vop_norename, 131 .vop_revoke = VOP_PANIC, 132 .vop_strategy = vop_nostrategy, 133 .vop_unlock = vop_stdunlock, 134 .vop_vptocnp = vop_stdvptocnp, 135 .vop_vptofh = vop_stdvptofh, 136 .vop_unp_bind = vop_stdunp_bind, 137 .vop_unp_connect = vop_stdunp_connect, 138 .vop_unp_detach = vop_stdunp_detach, 139 .vop_is_text = vop_stdis_text, 140 .vop_set_text = vop_stdset_text, 141 .vop_unset_text = vop_stdunset_text, 142 .vop_add_writecount = vop_stdadd_writecount, 143 }; 144 145 /* 146 * Series of placeholder functions for various error returns for 147 * VOPs. 148 */ 149 150 int 151 vop_eopnotsupp(struct vop_generic_args *ap) 152 { 153 /* 154 printf("vop_notsupp[%s]\n", ap->a_desc->vdesc_name); 155 */ 156 157 return (EOPNOTSUPP); 158 } 159 160 int 161 vop_ebadf(struct vop_generic_args *ap) 162 { 163 164 return (EBADF); 165 } 166 167 int 168 vop_enotty(struct vop_generic_args *ap) 169 { 170 171 return (ENOTTY); 172 } 173 174 int 175 vop_einval(struct vop_generic_args *ap) 176 { 177 178 return (EINVAL); 179 } 180 181 int 182 vop_enoent(struct vop_generic_args *ap) 183 { 184 185 return (ENOENT); 186 } 187 188 int 189 vop_null(struct vop_generic_args *ap) 190 { 191 192 return (0); 193 } 194 195 /* 196 * Helper function to panic on some bad VOPs in some filesystems. 197 */ 198 int 199 vop_panic(struct vop_generic_args *ap) 200 { 201 202 panic("filesystem goof: vop_panic[%s]", ap->a_desc->vdesc_name); 203 } 204 205 /* 206 * vop_std<something> and vop_no<something> are default functions for use by 207 * filesystems that need the "default reasonable" implementation for a 208 * particular operation. 209 * 210 * The documentation for the operations they implement exists (if it exists) 211 * in the VOP_<SOMETHING>(9) manpage (all uppercase). 212 */ 213 214 /* 215 * Default vop for filesystems that do not support name lookup 216 */ 217 static int 218 vop_nolookup(ap) 219 struct vop_lookup_args /* { 220 struct vnode *a_dvp; 221 struct vnode **a_vpp; 222 struct componentname *a_cnp; 223 } */ *ap; 224 { 225 226 *ap->a_vpp = NULL; 227 return (ENOTDIR); 228 } 229 230 /* 231 * vop_norename: 232 * 233 * Handle unlock and reference counting for arguments of vop_rename 234 * for filesystems that do not implement rename operation. 235 */ 236 static int 237 vop_norename(struct vop_rename_args *ap) 238 { 239 240 vop_rename_fail(ap); 241 return (EOPNOTSUPP); 242 } 243 244 /* 245 * vop_nostrategy: 246 * 247 * Strategy routine for VFS devices that have none. 248 * 249 * BIO_ERROR and B_INVAL must be cleared prior to calling any strategy 250 * routine. Typically this is done for a BIO_READ strategy call. 251 * Typically B_INVAL is assumed to already be clear prior to a write 252 * and should not be cleared manually unless you just made the buffer 253 * invalid. BIO_ERROR should be cleared either way. 254 */ 255 256 static int 257 vop_nostrategy (struct vop_strategy_args *ap) 258 { 259 printf("No strategy for buffer at %p\n", ap->a_bp); 260 vn_printf(ap->a_vp, "vnode "); 261 ap->a_bp->b_ioflags |= BIO_ERROR; 262 ap->a_bp->b_error = EOPNOTSUPP; 263 bufdone(ap->a_bp); 264 return (EOPNOTSUPP); 265 } 266 267 static int 268 get_next_dirent(struct vnode *vp, struct dirent **dpp, char *dirbuf, 269 int dirbuflen, off_t *off, char **cpos, int *len, 270 int *eofflag, struct thread *td) 271 { 272 int error, reclen; 273 struct uio uio; 274 struct iovec iov; 275 struct dirent *dp; 276 277 KASSERT(VOP_ISLOCKED(vp), ("vp %p is not locked", vp)); 278 KASSERT(vp->v_type == VDIR, ("vp %p is not a directory", vp)); 279 280 if (*len == 0) { 281 iov.iov_base = dirbuf; 282 iov.iov_len = dirbuflen; 283 284 uio.uio_iov = &iov; 285 uio.uio_iovcnt = 1; 286 uio.uio_offset = *off; 287 uio.uio_resid = dirbuflen; 288 uio.uio_segflg = UIO_SYSSPACE; 289 uio.uio_rw = UIO_READ; 290 uio.uio_td = td; 291 292 *eofflag = 0; 293 294 #ifdef MAC 295 error = mac_vnode_check_readdir(td->td_ucred, vp); 296 if (error == 0) 297 #endif 298 error = VOP_READDIR(vp, &uio, td->td_ucred, eofflag, 299 NULL, NULL); 300 if (error) 301 return (error); 302 303 *off = uio.uio_offset; 304 305 *cpos = dirbuf; 306 *len = (dirbuflen - uio.uio_resid); 307 308 if (*len == 0) 309 return (ENOENT); 310 } 311 312 dp = (struct dirent *)(*cpos); 313 reclen = dp->d_reclen; 314 *dpp = dp; 315 316 /* check for malformed directory.. */ 317 if (reclen < DIRENT_MINSIZE) 318 return (EINVAL); 319 320 *cpos += reclen; 321 *len -= reclen; 322 323 return (0); 324 } 325 326 /* 327 * Check if a named file exists in a given directory vnode. 328 */ 329 static int 330 dirent_exists(struct vnode *vp, const char *dirname, struct thread *td) 331 { 332 char *dirbuf, *cpos; 333 int error, eofflag, dirbuflen, len, found; 334 off_t off; 335 struct dirent *dp; 336 struct vattr va; 337 338 KASSERT(VOP_ISLOCKED(vp), ("vp %p is not locked", vp)); 339 KASSERT(vp->v_type == VDIR, ("vp %p is not a directory", vp)); 340 341 found = 0; 342 343 error = VOP_GETATTR(vp, &va, td->td_ucred); 344 if (error) 345 return (found); 346 347 dirbuflen = DEV_BSIZE; 348 if (dirbuflen < va.va_blocksize) 349 dirbuflen = va.va_blocksize; 350 dirbuf = (char *)malloc(dirbuflen, M_TEMP, M_WAITOK); 351 352 off = 0; 353 len = 0; 354 do { 355 error = get_next_dirent(vp, &dp, dirbuf, dirbuflen, &off, 356 &cpos, &len, &eofflag, td); 357 if (error) 358 goto out; 359 360 if (dp->d_type != DT_WHT && dp->d_fileno != 0 && 361 strcmp(dp->d_name, dirname) == 0) { 362 found = 1; 363 goto out; 364 } 365 } while (len > 0 || !eofflag); 366 367 out: 368 free(dirbuf, M_TEMP); 369 return (found); 370 } 371 372 int 373 vop_stdaccess(struct vop_access_args *ap) 374 { 375 376 KASSERT((ap->a_accmode & ~(VEXEC | VWRITE | VREAD | VADMIN | 377 VAPPEND)) == 0, ("invalid bit in accmode")); 378 379 return (VOP_ACCESSX(ap->a_vp, ap->a_accmode, ap->a_cred, ap->a_td)); 380 } 381 382 int 383 vop_stdaccessx(struct vop_accessx_args *ap) 384 { 385 int error; 386 accmode_t accmode = ap->a_accmode; 387 388 error = vfs_unixify_accmode(&accmode); 389 if (error != 0) 390 return (error); 391 392 if (accmode == 0) 393 return (0); 394 395 return (VOP_ACCESS(ap->a_vp, accmode, ap->a_cred, ap->a_td)); 396 } 397 398 /* 399 * Advisory record locking support 400 */ 401 int 402 vop_stdadvlock(struct vop_advlock_args *ap) 403 { 404 struct vnode *vp; 405 struct vattr vattr; 406 int error; 407 408 vp = ap->a_vp; 409 if (ap->a_fl->l_whence == SEEK_END) { 410 /* 411 * The NFSv4 server must avoid doing a vn_lock() here, since it 412 * can deadlock the nfsd threads, due to a LOR. Fortunately 413 * the NFSv4 server always uses SEEK_SET and this code is 414 * only required for the SEEK_END case. 415 */ 416 vn_lock(vp, LK_SHARED | LK_RETRY); 417 error = VOP_GETATTR(vp, &vattr, curthread->td_ucred); 418 VOP_UNLOCK(vp, 0); 419 if (error) 420 return (error); 421 } else 422 vattr.va_size = 0; 423 424 return (lf_advlock(ap, &(vp->v_lockf), vattr.va_size)); 425 } 426 427 int 428 vop_stdadvlockasync(struct vop_advlockasync_args *ap) 429 { 430 struct vnode *vp; 431 struct vattr vattr; 432 int error; 433 434 vp = ap->a_vp; 435 if (ap->a_fl->l_whence == SEEK_END) { 436 /* The size argument is only needed for SEEK_END. */ 437 vn_lock(vp, LK_SHARED | LK_RETRY); 438 error = VOP_GETATTR(vp, &vattr, curthread->td_ucred); 439 VOP_UNLOCK(vp, 0); 440 if (error) 441 return (error); 442 } else 443 vattr.va_size = 0; 444 445 return (lf_advlockasync(ap, &(vp->v_lockf), vattr.va_size)); 446 } 447 448 int 449 vop_stdadvlockpurge(struct vop_advlockpurge_args *ap) 450 { 451 struct vnode *vp; 452 453 vp = ap->a_vp; 454 lf_purgelocks(vp, &vp->v_lockf); 455 return (0); 456 } 457 458 /* 459 * vop_stdpathconf: 460 * 461 * Standard implementation of POSIX pathconf, to get information about limits 462 * for a filesystem. 463 * Override per filesystem for the case where the filesystem has smaller 464 * limits. 465 */ 466 int 467 vop_stdpathconf(ap) 468 struct vop_pathconf_args /* { 469 struct vnode *a_vp; 470 int a_name; 471 int *a_retval; 472 } */ *ap; 473 { 474 475 switch (ap->a_name) { 476 case _PC_ASYNC_IO: 477 *ap->a_retval = _POSIX_ASYNCHRONOUS_IO; 478 return (0); 479 case _PC_PATH_MAX: 480 *ap->a_retval = PATH_MAX; 481 return (0); 482 case _PC_ACL_EXTENDED: 483 case _PC_ACL_NFS4: 484 case _PC_CAP_PRESENT: 485 case _PC_INF_PRESENT: 486 case _PC_MAC_PRESENT: 487 *ap->a_retval = 0; 488 return (0); 489 default: 490 return (EINVAL); 491 } 492 /* NOTREACHED */ 493 } 494 495 /* 496 * Standard lock, unlock and islocked functions. 497 */ 498 int 499 vop_stdlock(ap) 500 struct vop_lock1_args /* { 501 struct vnode *a_vp; 502 int a_flags; 503 char *file; 504 int line; 505 } */ *ap; 506 { 507 struct vnode *vp = ap->a_vp; 508 struct mtx *ilk; 509 510 ilk = VI_MTX(vp); 511 return (lockmgr_lock_fast_path(vp->v_vnlock, ap->a_flags, 512 &ilk->lock_object, ap->a_file, ap->a_line)); 513 } 514 515 /* See above. */ 516 int 517 vop_stdunlock(ap) 518 struct vop_unlock_args /* { 519 struct vnode *a_vp; 520 int a_flags; 521 } */ *ap; 522 { 523 struct vnode *vp = ap->a_vp; 524 struct mtx *ilk; 525 526 ilk = VI_MTX(vp); 527 return (lockmgr_unlock_fast_path(vp->v_vnlock, ap->a_flags, 528 &ilk->lock_object)); 529 } 530 531 /* See above. */ 532 int 533 vop_stdislocked(ap) 534 struct vop_islocked_args /* { 535 struct vnode *a_vp; 536 } */ *ap; 537 { 538 539 return (lockstatus(ap->a_vp->v_vnlock)); 540 } 541 542 /* 543 * Return true for select/poll. 544 */ 545 int 546 vop_nopoll(ap) 547 struct vop_poll_args /* { 548 struct vnode *a_vp; 549 int a_events; 550 struct ucred *a_cred; 551 struct thread *a_td; 552 } */ *ap; 553 { 554 555 return (poll_no_poll(ap->a_events)); 556 } 557 558 /* 559 * Implement poll for local filesystems that support it. 560 */ 561 int 562 vop_stdpoll(ap) 563 struct vop_poll_args /* { 564 struct vnode *a_vp; 565 int a_events; 566 struct ucred *a_cred; 567 struct thread *a_td; 568 } */ *ap; 569 { 570 if (ap->a_events & ~POLLSTANDARD) 571 return (vn_pollrecord(ap->a_vp, ap->a_td, ap->a_events)); 572 return (ap->a_events & (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM)); 573 } 574 575 /* 576 * Return our mount point, as we will take charge of the writes. 577 */ 578 int 579 vop_stdgetwritemount(ap) 580 struct vop_getwritemount_args /* { 581 struct vnode *a_vp; 582 struct mount **a_mpp; 583 } */ *ap; 584 { 585 struct mount *mp; 586 587 /* 588 * XXX Since this is called unlocked we may be recycled while 589 * attempting to ref the mount. If this is the case or mountpoint 590 * will be set to NULL. We only have to prevent this call from 591 * returning with a ref to an incorrect mountpoint. It is not 592 * harmful to return with a ref to our previous mountpoint. 593 */ 594 mp = ap->a_vp->v_mount; 595 if (mp != NULL) { 596 vfs_ref(mp); 597 if (mp != ap->a_vp->v_mount) { 598 vfs_rel(mp); 599 mp = NULL; 600 } 601 } 602 *(ap->a_mpp) = mp; 603 return (0); 604 } 605 606 /* XXX Needs good comment and VOP_BMAP(9) manpage */ 607 int 608 vop_stdbmap(ap) 609 struct vop_bmap_args /* { 610 struct vnode *a_vp; 611 daddr_t a_bn; 612 struct bufobj **a_bop; 613 daddr_t *a_bnp; 614 int *a_runp; 615 int *a_runb; 616 } */ *ap; 617 { 618 619 if (ap->a_bop != NULL) 620 *ap->a_bop = &ap->a_vp->v_bufobj; 621 if (ap->a_bnp != NULL) 622 *ap->a_bnp = ap->a_bn * btodb(ap->a_vp->v_mount->mnt_stat.f_iosize); 623 if (ap->a_runp != NULL) 624 *ap->a_runp = 0; 625 if (ap->a_runb != NULL) 626 *ap->a_runb = 0; 627 return (0); 628 } 629 630 int 631 vop_stdfsync(ap) 632 struct vop_fsync_args /* { 633 struct vnode *a_vp; 634 int a_waitfor; 635 struct thread *a_td; 636 } */ *ap; 637 { 638 639 return (vn_fsync_buf(ap->a_vp, ap->a_waitfor)); 640 } 641 642 static int 643 vop_stdfdatasync(struct vop_fdatasync_args *ap) 644 { 645 646 return (VOP_FSYNC(ap->a_vp, MNT_WAIT, ap->a_td)); 647 } 648 649 int 650 vop_stdfdatasync_buf(struct vop_fdatasync_args *ap) 651 { 652 653 return (vn_fsync_buf(ap->a_vp, MNT_WAIT)); 654 } 655 656 /* XXX Needs good comment and more info in the manpage (VOP_GETPAGES(9)). */ 657 int 658 vop_stdgetpages(ap) 659 struct vop_getpages_args /* { 660 struct vnode *a_vp; 661 vm_page_t *a_m; 662 int a_count; 663 int *a_rbehind; 664 int *a_rahead; 665 } */ *ap; 666 { 667 668 return vnode_pager_generic_getpages(ap->a_vp, ap->a_m, 669 ap->a_count, ap->a_rbehind, ap->a_rahead, NULL, NULL); 670 } 671 672 static int 673 vop_stdgetpages_async(struct vop_getpages_async_args *ap) 674 { 675 int error; 676 677 error = VOP_GETPAGES(ap->a_vp, ap->a_m, ap->a_count, ap->a_rbehind, 678 ap->a_rahead); 679 ap->a_iodone(ap->a_arg, ap->a_m, ap->a_count, error); 680 return (error); 681 } 682 683 int 684 vop_stdkqfilter(struct vop_kqfilter_args *ap) 685 { 686 return vfs_kqfilter(ap); 687 } 688 689 /* XXX Needs good comment and more info in the manpage (VOP_PUTPAGES(9)). */ 690 int 691 vop_stdputpages(ap) 692 struct vop_putpages_args /* { 693 struct vnode *a_vp; 694 vm_page_t *a_m; 695 int a_count; 696 int a_sync; 697 int *a_rtvals; 698 } */ *ap; 699 { 700 701 return vnode_pager_generic_putpages(ap->a_vp, ap->a_m, ap->a_count, 702 ap->a_sync, ap->a_rtvals); 703 } 704 705 int 706 vop_stdvptofh(struct vop_vptofh_args *ap) 707 { 708 return (EOPNOTSUPP); 709 } 710 711 int 712 vop_stdvptocnp(struct vop_vptocnp_args *ap) 713 { 714 struct vnode *vp = ap->a_vp; 715 struct vnode **dvp = ap->a_vpp; 716 struct ucred *cred = ap->a_cred; 717 char *buf = ap->a_buf; 718 int *buflen = ap->a_buflen; 719 char *dirbuf, *cpos; 720 int i, error, eofflag, dirbuflen, flags, locked, len, covered; 721 off_t off; 722 ino_t fileno; 723 struct vattr va; 724 struct nameidata nd; 725 struct thread *td; 726 struct dirent *dp; 727 struct vnode *mvp; 728 729 i = *buflen; 730 error = 0; 731 covered = 0; 732 td = curthread; 733 734 if (vp->v_type != VDIR) 735 return (ENOENT); 736 737 error = VOP_GETATTR(vp, &va, cred); 738 if (error) 739 return (error); 740 741 VREF(vp); 742 locked = VOP_ISLOCKED(vp); 743 VOP_UNLOCK(vp, 0); 744 NDINIT_ATVP(&nd, LOOKUP, FOLLOW | LOCKSHARED | LOCKLEAF, UIO_SYSSPACE, 745 "..", vp, td); 746 flags = FREAD; 747 error = vn_open_cred(&nd, &flags, 0, VN_OPEN_NOAUDIT, cred, NULL); 748 if (error) { 749 vn_lock(vp, locked | LK_RETRY); 750 return (error); 751 } 752 NDFREE(&nd, NDF_ONLY_PNBUF); 753 754 mvp = *dvp = nd.ni_vp; 755 756 if (vp->v_mount != (*dvp)->v_mount && 757 ((*dvp)->v_vflag & VV_ROOT) && 758 ((*dvp)->v_mount->mnt_flag & MNT_UNION)) { 759 *dvp = (*dvp)->v_mount->mnt_vnodecovered; 760 VREF(mvp); 761 VOP_UNLOCK(mvp, 0); 762 vn_close(mvp, FREAD, cred, td); 763 VREF(*dvp); 764 vn_lock(*dvp, LK_SHARED | LK_RETRY); 765 covered = 1; 766 } 767 768 fileno = va.va_fileid; 769 770 dirbuflen = DEV_BSIZE; 771 if (dirbuflen < va.va_blocksize) 772 dirbuflen = va.va_blocksize; 773 dirbuf = (char *)malloc(dirbuflen, M_TEMP, M_WAITOK); 774 775 if ((*dvp)->v_type != VDIR) { 776 error = ENOENT; 777 goto out; 778 } 779 780 off = 0; 781 len = 0; 782 do { 783 /* call VOP_READDIR of parent */ 784 error = get_next_dirent(*dvp, &dp, dirbuf, dirbuflen, &off, 785 &cpos, &len, &eofflag, td); 786 if (error) 787 goto out; 788 789 if ((dp->d_type != DT_WHT) && 790 (dp->d_fileno == fileno)) { 791 if (covered) { 792 VOP_UNLOCK(*dvp, 0); 793 vn_lock(mvp, LK_SHARED | LK_RETRY); 794 if (dirent_exists(mvp, dp->d_name, td)) { 795 error = ENOENT; 796 VOP_UNLOCK(mvp, 0); 797 vn_lock(*dvp, LK_SHARED | LK_RETRY); 798 goto out; 799 } 800 VOP_UNLOCK(mvp, 0); 801 vn_lock(*dvp, LK_SHARED | LK_RETRY); 802 } 803 i -= dp->d_namlen; 804 805 if (i < 0) { 806 error = ENOMEM; 807 goto out; 808 } 809 if (dp->d_namlen == 1 && dp->d_name[0] == '.') { 810 error = ENOENT; 811 } else { 812 bcopy(dp->d_name, buf + i, dp->d_namlen); 813 error = 0; 814 } 815 goto out; 816 } 817 } while (len > 0 || !eofflag); 818 error = ENOENT; 819 820 out: 821 free(dirbuf, M_TEMP); 822 if (!error) { 823 *buflen = i; 824 vref(*dvp); 825 } 826 if (covered) { 827 vput(*dvp); 828 vrele(mvp); 829 } else { 830 VOP_UNLOCK(mvp, 0); 831 vn_close(mvp, FREAD, cred, td); 832 } 833 vn_lock(vp, locked | LK_RETRY); 834 return (error); 835 } 836 837 int 838 vop_stdallocate(struct vop_allocate_args *ap) 839 { 840 #ifdef __notyet__ 841 struct statfs *sfs; 842 off_t maxfilesize = 0; 843 #endif 844 struct iovec aiov; 845 struct vattr vattr, *vap; 846 struct uio auio; 847 off_t fsize, len, cur, offset; 848 uint8_t *buf; 849 struct thread *td; 850 struct vnode *vp; 851 size_t iosize; 852 int error; 853 854 buf = NULL; 855 error = 0; 856 td = curthread; 857 vap = &vattr; 858 vp = ap->a_vp; 859 len = *ap->a_len; 860 offset = *ap->a_offset; 861 862 error = VOP_GETATTR(vp, vap, td->td_ucred); 863 if (error != 0) 864 goto out; 865 fsize = vap->va_size; 866 iosize = vap->va_blocksize; 867 if (iosize == 0) 868 iosize = BLKDEV_IOSIZE; 869 if (iosize > MAXPHYS) 870 iosize = MAXPHYS; 871 buf = malloc(iosize, M_TEMP, M_WAITOK); 872 873 #ifdef __notyet__ 874 /* 875 * Check if the filesystem sets f_maxfilesize; if not use 876 * VOP_SETATTR to perform the check. 877 */ 878 sfs = malloc(sizeof(struct statfs), M_STATFS, M_WAITOK); 879 error = VFS_STATFS(vp->v_mount, sfs, td); 880 if (error == 0) 881 maxfilesize = sfs->f_maxfilesize; 882 free(sfs, M_STATFS); 883 if (error != 0) 884 goto out; 885 if (maxfilesize) { 886 if (offset > maxfilesize || len > maxfilesize || 887 offset + len > maxfilesize) { 888 error = EFBIG; 889 goto out; 890 } 891 } else 892 #endif 893 if (offset + len > vap->va_size) { 894 /* 895 * Test offset + len against the filesystem's maxfilesize. 896 */ 897 VATTR_NULL(vap); 898 vap->va_size = offset + len; 899 error = VOP_SETATTR(vp, vap, td->td_ucred); 900 if (error != 0) 901 goto out; 902 VATTR_NULL(vap); 903 vap->va_size = fsize; 904 error = VOP_SETATTR(vp, vap, td->td_ucred); 905 if (error != 0) 906 goto out; 907 } 908 909 for (;;) { 910 /* 911 * Read and write back anything below the nominal file 912 * size. There's currently no way outside the filesystem 913 * to know whether this area is sparse or not. 914 */ 915 cur = iosize; 916 if ((offset % iosize) != 0) 917 cur -= (offset % iosize); 918 if (cur > len) 919 cur = len; 920 if (offset < fsize) { 921 aiov.iov_base = buf; 922 aiov.iov_len = cur; 923 auio.uio_iov = &aiov; 924 auio.uio_iovcnt = 1; 925 auio.uio_offset = offset; 926 auio.uio_resid = cur; 927 auio.uio_segflg = UIO_SYSSPACE; 928 auio.uio_rw = UIO_READ; 929 auio.uio_td = td; 930 error = VOP_READ(vp, &auio, 0, td->td_ucred); 931 if (error != 0) 932 break; 933 if (auio.uio_resid > 0) { 934 bzero(buf + cur - auio.uio_resid, 935 auio.uio_resid); 936 } 937 } else { 938 bzero(buf, cur); 939 } 940 941 aiov.iov_base = buf; 942 aiov.iov_len = cur; 943 auio.uio_iov = &aiov; 944 auio.uio_iovcnt = 1; 945 auio.uio_offset = offset; 946 auio.uio_resid = cur; 947 auio.uio_segflg = UIO_SYSSPACE; 948 auio.uio_rw = UIO_WRITE; 949 auio.uio_td = td; 950 951 error = VOP_WRITE(vp, &auio, 0, td->td_ucred); 952 if (error != 0) 953 break; 954 955 len -= cur; 956 offset += cur; 957 if (len == 0) 958 break; 959 if (should_yield()) 960 break; 961 } 962 963 out: 964 *ap->a_len = len; 965 *ap->a_offset = offset; 966 free(buf, M_TEMP); 967 return (error); 968 } 969 970 int 971 vop_stdadvise(struct vop_advise_args *ap) 972 { 973 struct vnode *vp; 974 struct bufobj *bo; 975 daddr_t startn, endn; 976 off_t bstart, bend, start, end; 977 int bsize, error; 978 979 vp = ap->a_vp; 980 switch (ap->a_advice) { 981 case POSIX_FADV_WILLNEED: 982 /* 983 * Do nothing for now. Filesystems should provide a 984 * custom method which starts an asynchronous read of 985 * the requested region. 986 */ 987 error = 0; 988 break; 989 case POSIX_FADV_DONTNEED: 990 error = 0; 991 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); 992 if (vp->v_iflag & VI_DOOMED) { 993 VOP_UNLOCK(vp, 0); 994 break; 995 } 996 997 /* 998 * Round to block boundaries (and later possibly further to 999 * page boundaries). Applications cannot reasonably be aware 1000 * of the boundaries, and the rounding must be to expand at 1001 * both extremities to cover enough. It still doesn't cover 1002 * read-ahead. For partial blocks, this gives unnecessary 1003 * discarding of buffers but is efficient enough since the 1004 * pages usually remain in VMIO for some time. 1005 */ 1006 bsize = vp->v_bufobj.bo_bsize; 1007 bstart = rounddown(ap->a_start, bsize); 1008 bend = roundup(ap->a_end, bsize); 1009 1010 /* 1011 * Deactivate pages in the specified range from the backing VM 1012 * object. Pages that are resident in the buffer cache will 1013 * remain wired until their corresponding buffers are released 1014 * below. 1015 */ 1016 if (vp->v_object != NULL) { 1017 start = trunc_page(bstart); 1018 end = round_page(bend); 1019 VM_OBJECT_RLOCK(vp->v_object); 1020 vm_object_page_noreuse(vp->v_object, OFF_TO_IDX(start), 1021 OFF_TO_IDX(end)); 1022 VM_OBJECT_RUNLOCK(vp->v_object); 1023 } 1024 1025 bo = &vp->v_bufobj; 1026 BO_RLOCK(bo); 1027 startn = bstart / bsize; 1028 endn = bend / bsize; 1029 error = bnoreuselist(&bo->bo_clean, bo, startn, endn); 1030 if (error == 0) 1031 error = bnoreuselist(&bo->bo_dirty, bo, startn, endn); 1032 BO_RUNLOCK(bo); 1033 VOP_UNLOCK(vp, 0); 1034 break; 1035 default: 1036 error = EINVAL; 1037 break; 1038 } 1039 return (error); 1040 } 1041 1042 int 1043 vop_stdunp_bind(struct vop_unp_bind_args *ap) 1044 { 1045 1046 ap->a_vp->v_unpcb = ap->a_unpcb; 1047 return (0); 1048 } 1049 1050 int 1051 vop_stdunp_connect(struct vop_unp_connect_args *ap) 1052 { 1053 1054 *ap->a_unpcb = ap->a_vp->v_unpcb; 1055 return (0); 1056 } 1057 1058 int 1059 vop_stdunp_detach(struct vop_unp_detach_args *ap) 1060 { 1061 1062 ap->a_vp->v_unpcb = NULL; 1063 return (0); 1064 } 1065 1066 static int 1067 vop_stdis_text(struct vop_is_text_args *ap) 1068 { 1069 1070 return (ap->a_vp->v_writecount < 0); 1071 } 1072 1073 int 1074 vop_stdset_text(struct vop_set_text_args *ap) 1075 { 1076 struct vnode *vp; 1077 int error; 1078 1079 vp = ap->a_vp; 1080 VI_LOCK(vp); 1081 if (vp->v_writecount > 0) { 1082 error = ETXTBSY; 1083 } else { 1084 vp->v_writecount--; 1085 error = 0; 1086 } 1087 VI_UNLOCK(vp); 1088 return (error); 1089 } 1090 1091 static int 1092 vop_stdunset_text(struct vop_unset_text_args *ap) 1093 { 1094 struct vnode *vp; 1095 int error; 1096 1097 vp = ap->a_vp; 1098 VI_LOCK(vp); 1099 if (vp->v_writecount < 0) { 1100 vp->v_writecount++; 1101 error = 0; 1102 } else { 1103 error = EINVAL; 1104 } 1105 VI_UNLOCK(vp); 1106 return (error); 1107 } 1108 1109 static int 1110 vop_stdadd_writecount(struct vop_add_writecount_args *ap) 1111 { 1112 struct vnode *vp; 1113 int error; 1114 1115 vp = ap->a_vp; 1116 VI_LOCK_FLAGS(vp, MTX_DUPOK); 1117 if (vp->v_writecount < 0) { 1118 error = ETXTBSY; 1119 } else { 1120 VNASSERT(vp->v_writecount + ap->a_inc >= 0, vp, 1121 ("neg writecount increment %d", ap->a_inc)); 1122 vp->v_writecount += ap->a_inc; 1123 error = 0; 1124 } 1125 VI_UNLOCK(vp); 1126 return (error); 1127 } 1128 1129 /* 1130 * vfs default ops 1131 * used to fill the vfs function table to get reasonable default return values. 1132 */ 1133 int 1134 vfs_stdroot (mp, flags, vpp) 1135 struct mount *mp; 1136 int flags; 1137 struct vnode **vpp; 1138 { 1139 1140 return (EOPNOTSUPP); 1141 } 1142 1143 int 1144 vfs_stdstatfs (mp, sbp) 1145 struct mount *mp; 1146 struct statfs *sbp; 1147 { 1148 1149 return (EOPNOTSUPP); 1150 } 1151 1152 int 1153 vfs_stdquotactl (mp, cmds, uid, arg) 1154 struct mount *mp; 1155 int cmds; 1156 uid_t uid; 1157 void *arg; 1158 { 1159 1160 return (EOPNOTSUPP); 1161 } 1162 1163 int 1164 vfs_stdsync(mp, waitfor) 1165 struct mount *mp; 1166 int waitfor; 1167 { 1168 struct vnode *vp, *mvp; 1169 struct thread *td; 1170 int error, lockreq, allerror = 0; 1171 1172 td = curthread; 1173 lockreq = LK_EXCLUSIVE | LK_INTERLOCK; 1174 if (waitfor != MNT_WAIT) 1175 lockreq |= LK_NOWAIT; 1176 /* 1177 * Force stale buffer cache information to be flushed. 1178 */ 1179 loop: 1180 MNT_VNODE_FOREACH_ALL(vp, mp, mvp) { 1181 if (vp->v_bufobj.bo_dirty.bv_cnt == 0) { 1182 VI_UNLOCK(vp); 1183 continue; 1184 } 1185 if ((error = vget(vp, lockreq, td)) != 0) { 1186 if (error == ENOENT) { 1187 MNT_VNODE_FOREACH_ALL_ABORT(mp, mvp); 1188 goto loop; 1189 } 1190 continue; 1191 } 1192 error = VOP_FSYNC(vp, waitfor, td); 1193 if (error) 1194 allerror = error; 1195 vput(vp); 1196 } 1197 return (allerror); 1198 } 1199 1200 int 1201 vfs_stdnosync (mp, waitfor) 1202 struct mount *mp; 1203 int waitfor; 1204 { 1205 1206 return (0); 1207 } 1208 1209 int 1210 vfs_stdvget (mp, ino, flags, vpp) 1211 struct mount *mp; 1212 ino_t ino; 1213 int flags; 1214 struct vnode **vpp; 1215 { 1216 1217 return (EOPNOTSUPP); 1218 } 1219 1220 int 1221 vfs_stdfhtovp (mp, fhp, flags, vpp) 1222 struct mount *mp; 1223 struct fid *fhp; 1224 int flags; 1225 struct vnode **vpp; 1226 { 1227 1228 return (EOPNOTSUPP); 1229 } 1230 1231 int 1232 vfs_stdinit (vfsp) 1233 struct vfsconf *vfsp; 1234 { 1235 1236 return (0); 1237 } 1238 1239 int 1240 vfs_stduninit (vfsp) 1241 struct vfsconf *vfsp; 1242 { 1243 1244 return(0); 1245 } 1246 1247 int 1248 vfs_stdextattrctl(mp, cmd, filename_vp, attrnamespace, attrname) 1249 struct mount *mp; 1250 int cmd; 1251 struct vnode *filename_vp; 1252 int attrnamespace; 1253 const char *attrname; 1254 { 1255 1256 if (filename_vp != NULL) 1257 VOP_UNLOCK(filename_vp, 0); 1258 return (EOPNOTSUPP); 1259 } 1260 1261 int 1262 vfs_stdsysctl(mp, op, req) 1263 struct mount *mp; 1264 fsctlop_t op; 1265 struct sysctl_req *req; 1266 { 1267 1268 return (EOPNOTSUPP); 1269 } 1270 1271 static vop_bypass_t * 1272 bp_by_off(struct vop_vector *vop, struct vop_generic_args *a) 1273 { 1274 1275 return (*(vop_bypass_t **)((char *)vop + a->a_desc->vdesc_vop_offset)); 1276 } 1277 1278 int 1279 vop_sigdefer(struct vop_vector *vop, struct vop_generic_args *a) 1280 { 1281 vop_bypass_t *bp; 1282 int prev_stops, rc; 1283 1284 for (; vop != NULL; vop = vop->vop_default) { 1285 bp = bp_by_off(vop, a); 1286 if (bp != NULL) 1287 break; 1288 1289 /* 1290 * Bypass is not really supported. It is done for 1291 * fallback to unimplemented vops in the default 1292 * vector. 1293 */ 1294 bp = vop->vop_bypass; 1295 if (bp != NULL) 1296 break; 1297 } 1298 MPASS(bp != NULL); 1299 1300 prev_stops = sigdeferstop(SIGDEFERSTOP_SILENT); 1301 rc = bp(a); 1302 sigallowstop(prev_stops); 1303 return (rc); 1304 } 1305