sys/kern/vfs_default.c

   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/filio.h>
  47 #include <sys/kernel.h>
  48 #include <sys/limits.h>
  49 #include <sys/lock.h>
  50 #include <sys/lockf.h>
  51 #include <sys/malloc.h>
  52 #include <sys/mount.h>
  53 #include <sys/namei.h>
  54 #include <sys/rwlock.h>
  55 #include <sys/fcntl.h>
  56 #include <sys/unistd.h>
  57 #include <sys/vnode.h>
  58 #include <sys/dirent.h>
  59 #include <sys/poll.h>
  60 #include <sys/stat.h>
  61 #include <security/audit/audit.h>
  62 #include <sys/priv.h>
  63
  64 #include <security/mac/mac_framework.h>
  65
  66 #include <vm/vm.h>
  67 #include <vm/vm_object.h>
  68 #include <vm/vm_extern.h>
  69 #include <vm/pmap.h>
  70 #include <vm/vm_map.h>
  71 #include <vm/vm_page.h>
  72 #include <vm/vm_pager.h>
  73 #include <vm/vnode_pager.h>
  74
  75 static int      vop_nolookup(struct vop_lookup_args *);
  76 static int      vop_norename(struct vop_rename_args *);
  77 static int      vop_nostrategy(struct vop_strategy_args *);
  78 static int      get_next_dirent(struct vnode *vp, struct dirent **dpp,
  79                                 char *dirbuf, int dirbuflen, off_t *off,
  80                                 char **cpos, int *len, int *eofflag,
  81                                 struct thread *td);
  82 static int      dirent_exists(struct vnode *vp, const char *dirname,
  83                               struct thread *td);
  84
  85 #define DIRENT_MINSIZE (sizeof(struct dirent) - (MAXNAMLEN+1) + 4)
  86
  87 static int vop_stdis_text(struct vop_is_text_args *ap);
  88 static int vop_stdunset_text(struct vop_unset_text_args *ap);
  89 static int vop_stdadd_writecount(struct vop_add_writecount_args *ap);
  90 static int vop_stdcopy_file_range(struct vop_copy_file_range_args *ap);
  91 static int vop_stdfdatasync(struct vop_fdatasync_args *ap);
  92 static int vop_stdgetpages_async(struct vop_getpages_async_args *ap);
  93 static int vop_stdread_pgcache(struct vop_read_pgcache_args *ap);
  94 static int vop_stdstat(struct vop_stat_args *ap);
  95 static int vop_stdvput_pair(struct vop_vput_pair_args *ap);
  96
  97 /*
  98  * This vnode table stores what we want to do if the filesystem doesn't
  99  * implement a particular VOP.
 100  *
 101  * If there is no specific entry here, we will return EOPNOTSUPP.
 102  *
 103  * Note that every filesystem has to implement either vop_access
 104  * or vop_accessx; failing to do so will result in immediate crash
 105  * due to stack overflow, as vop_stdaccess() calls vop_stdaccessx(),
 106  * which calls vop_stdaccess() etc.
 107  */
 108
 109 struct vop_vector default_vnodeops = {
 110         .vop_default =          NULL,
 111         .vop_bypass =           VOP_EOPNOTSUPP,
 112
 113         .vop_access =           vop_stdaccess,
 114         .vop_accessx =          vop_stdaccessx,
 115         .vop_advise =           vop_stdadvise,
 116         .vop_advlock =          vop_stdadvlock,
 117         .vop_advlockasync =     vop_stdadvlockasync,
 118         .vop_advlockpurge =     vop_stdadvlockpurge,
 119         .vop_allocate =         vop_stdallocate,
 120         .vop_bmap =             vop_stdbmap,
 121         .vop_close =            VOP_NULL,
 122         .vop_fsync =            VOP_NULL,
 123         .vop_stat =             vop_stdstat,
 124         .vop_fdatasync =        vop_stdfdatasync,
 125         .vop_getpages =         vop_stdgetpages,
 126         .vop_getpages_async =   vop_stdgetpages_async,
 127         .vop_getwritemount =    vop_stdgetwritemount,
 128         .vop_inactive =         VOP_NULL,
 129         .vop_need_inactive =    vop_stdneed_inactive,
 130         .vop_ioctl =            vop_stdioctl,
 131         .vop_kqfilter =         vop_stdkqfilter,
 132         .vop_islocked =         vop_stdislocked,
 133         .vop_lock1 =            vop_stdlock,
 134         .vop_lookup =           vop_nolookup,
 135         .vop_open =             VOP_NULL,
 136         .vop_pathconf =         VOP_EINVAL,
 137         .vop_poll =             vop_nopoll,
 138         .vop_putpages =         vop_stdputpages,
 139         .vop_readlink =         VOP_EINVAL,
 140         .vop_read_pgcache =     vop_stdread_pgcache,
 141         .vop_rename =           vop_norename,
 142         .vop_revoke =           VOP_PANIC,
 143         .vop_strategy =         vop_nostrategy,
 144         .vop_unlock =           vop_stdunlock,
 145         .vop_vptocnp =          vop_stdvptocnp,
 146         .vop_vptofh =           vop_stdvptofh,
 147         .vop_unp_bind =         vop_stdunp_bind,
 148         .vop_unp_connect =      vop_stdunp_connect,
 149         .vop_unp_detach =       vop_stdunp_detach,
 150         .vop_is_text =          vop_stdis_text,
 151         .vop_set_text =         vop_stdset_text,
 152         .vop_unset_text =       vop_stdunset_text,
 153         .vop_add_writecount =   vop_stdadd_writecount,
 154         .vop_copy_file_range =  vop_stdcopy_file_range,
 155         .vop_vput_pair =        vop_stdvput_pair,
 156 };
 157 VFS_VOP_VECTOR_REGISTER(default_vnodeops);
 158
 159 /*
 160  * Series of placeholder functions for various error returns for
 161  * VOPs.
 162  */
 163
 164 int
 165 vop_eopnotsupp(struct vop_generic_args *ap)
 166 {
 167         /*
 168         printf("vop_notsupp[%s]\n", ap->a_desc->vdesc_name);
 169         */
 170
 171         return (EOPNOTSUPP);
 172 }
 173
 174 int
 175 vop_ebadf(struct vop_generic_args *ap)
 176 {
 177
 178         return (EBADF);
 179 }
 180
 181 int
 182 vop_enotty(struct vop_generic_args *ap)
 183 {
 184
 185         return (ENOTTY);
 186 }
 187
 188 int
 189 vop_einval(struct vop_generic_args *ap)
 190 {
 191
 192         return (EINVAL);
 193 }
 194
 195 int
 196 vop_enoent(struct vop_generic_args *ap)
 197 {
 198
 199         return (ENOENT);
 200 }
 201
 202 int
 203 vop_eagain(struct vop_generic_args *ap)
 204 {
 205
 206         return (EAGAIN);
 207 }
 208
 209 int
 210 vop_null(struct vop_generic_args *ap)
 211 {
 212
 213         return (0);
 214 }
 215
 216 /*
 217  * Helper function to panic on some bad VOPs in some filesystems.
 218  */
 219 int
 220 vop_panic(struct vop_generic_args *ap)
 221 {
 222
 223         panic("filesystem goof: vop_panic[%s]", ap->a_desc->vdesc_name);
 224 }
 225
 226 /*
 227  * vop_std<something> and vop_no<something> are default functions for use by
 228  * filesystems that need the "default reasonable" implementation for a
 229  * particular operation.
 230  *
 231  * The documentation for the operations they implement exists (if it exists)
 232  * in the VOP_<SOMETHING>(9) manpage (all uppercase).
 233  */
 234
 235 /*
 236  * Default vop for filesystems that do not support name lookup
 237  */
 238 static int
 239 vop_nolookup(ap)
 240         struct vop_lookup_args /* {
 241                 struct vnode *a_dvp;
 242                 struct vnode **a_vpp;
 243                 struct componentname *a_cnp;
 244         } */ *ap;
 245 {
 246
 247         *ap->a_vpp = NULL;
 248         return (ENOTDIR);
 249 }
 250
 251 /*
 252  * vop_norename:
 253  *
 254  * Handle unlock and reference counting for arguments of vop_rename
 255  * for filesystems that do not implement rename operation.
 256  */
 257 static int
 258 vop_norename(struct vop_rename_args *ap)
 259 {
 260
 261         vop_rename_fail(ap);
 262         return (EOPNOTSUPP);
 263 }
 264
 265 /*
 266  *      vop_nostrategy:
 267  *
 268  *      Strategy routine for VFS devices that have none.
 269  *
 270  *      BIO_ERROR and B_INVAL must be cleared prior to calling any strategy
 271  *      routine.  Typically this is done for a BIO_READ strategy call.
 272  *      Typically B_INVAL is assumed to already be clear prior to a write
 273  *      and should not be cleared manually unless you just made the buffer
 274  *      invalid.  BIO_ERROR should be cleared either way.
 275  */
 276
 277 static int
 278 vop_nostrategy (struct vop_strategy_args *ap)
 279 {
 280         printf("No strategy for buffer at %p\n", ap->a_bp);
 281         vn_printf(ap->a_vp, "vnode ");
 282         ap->a_bp->b_ioflags |= BIO_ERROR;
 283         ap->a_bp->b_error = EOPNOTSUPP;
 284         bufdone(ap->a_bp);
 285         return (EOPNOTSUPP);
 286 }
 287
 288 static int
 289 get_next_dirent(struct vnode *vp, struct dirent **dpp, char *dirbuf,
 290                 int dirbuflen, off_t *off, char **cpos, int *len,
 291                 int *eofflag, struct thread *td)
 292 {
 293         int error, reclen;
 294         struct uio uio;
 295         struct iovec iov;
 296         struct dirent *dp;
 297
 298         KASSERT(VOP_ISLOCKED(vp), ("vp %p is not locked", vp));
 299         KASSERT(vp->v_type == VDIR, ("vp %p is not a directory", vp));
 300
 301         if (*len == 0) {
 302                 iov.iov_base = dirbuf;
 303                 iov.iov_len = dirbuflen;
 304
 305                 uio.uio_iov = &iov;
 306                 uio.uio_iovcnt = 1;
 307                 uio.uio_offset = *off;
 308                 uio.uio_resid = dirbuflen;
 309                 uio.uio_segflg = UIO_SYSSPACE;
 310                 uio.uio_rw = UIO_READ;
 311                 uio.uio_td = td;
 312
 313                 *eofflag = 0;
 314
 315 #ifdef MAC
 316                 error = mac_vnode_check_readdir(td->td_ucred, vp);
 317                 if (error == 0)
 318 #endif
 319                         error = VOP_READDIR(vp, &uio, td->td_ucred, eofflag,
 320                                 NULL, NULL);
 321                 if (error)
 322                         return (error);
 323
 324                 *off = uio.uio_offset;
 325
 326                 *cpos = dirbuf;
 327                 *len = (dirbuflen - uio.uio_resid);
 328
 329                 if (*len == 0)
 330                         return (ENOENT);
 331         }
 332
 333         dp = (struct dirent *)(*cpos);
 334         reclen = dp->d_reclen;
 335         *dpp = dp;
 336
 337         /* check for malformed directory.. */
 338         if (reclen < DIRENT_MINSIZE)
 339                 return (EINVAL);
 340
 341         *cpos += reclen;
 342         *len -= reclen;
 343
 344         return (0);
 345 }
 346
 347 /*
 348  * Check if a named file exists in a given directory vnode.
 349  */
 350 static int
 351 dirent_exists(struct vnode *vp, const char *dirname, struct thread *td)
 352 {
 353         char *dirbuf, *cpos;
 354         int error, eofflag, dirbuflen, len, found;
 355         off_t off;
 356         struct dirent *dp;
 357         struct vattr va;
 358
 359         KASSERT(VOP_ISLOCKED(vp), ("vp %p is not locked", vp));
 360         KASSERT(vp->v_type == VDIR, ("vp %p is not a directory", vp));
 361
 362         found = 0;
 363
 364         error = VOP_GETATTR(vp, &va, td->td_ucred);
 365         if (error)
 366                 return (found);
 367
 368         dirbuflen = DEV_BSIZE;
 369         if (dirbuflen < va.va_blocksize)
 370                 dirbuflen = va.va_blocksize;
 371         dirbuf = (char *)malloc(dirbuflen, M_TEMP, M_WAITOK);
 372
 373         off = 0;
 374         len = 0;
 375         do {
 376                 error = get_next_dirent(vp, &dp, dirbuf, dirbuflen, &off,
 377                                         &cpos, &len, &eofflag, td);
 378                 if (error)
 379                         goto out;
 380
 381                 if (dp->d_type != DT_WHT && dp->d_fileno != 0 &&
 382                     strcmp(dp->d_name, dirname) == 0) {
 383                         found = 1;
 384                         goto out;
 385                 }
 386         } while (len > 0 || !eofflag);
 387
 388 out:
 389         free(dirbuf, M_TEMP);
 390         return (found);
 391 }
 392
 393 int
 394 vop_stdaccess(struct vop_access_args *ap)
 395 {
 396
 397         KASSERT((ap->a_accmode & ~(VEXEC | VWRITE | VREAD | VADMIN |
 398             VAPPEND)) == 0, ("invalid bit in accmode"));
 399
 400         return (VOP_ACCESSX(ap->a_vp, ap->a_accmode, ap->a_cred, ap->a_td));
 401 }
 402
 403 int
 404 vop_stdaccessx(struct vop_accessx_args *ap)
 405 {
 406         int error;
 407         accmode_t accmode = ap->a_accmode;
 408
 409         error = vfs_unixify_accmode(&accmode);
 410         if (error != 0)
 411                 return (error);
 412
 413         if (accmode == 0)
 414                 return (0);
 415
 416         return (VOP_ACCESS(ap->a_vp, accmode, ap->a_cred, ap->a_td));
 417 }
 418
 419 /*
 420  * Advisory record locking support
 421  */
 422 int
 423 vop_stdadvlock(struct vop_advlock_args *ap)
 424 {
 425         struct vnode *vp;
 426         struct mount *mp;
 427         struct vattr vattr;
 428         int error;
 429
 430         vp = ap->a_vp;
 431
 432         /*
 433          * Provide atomicity of open(O_CREAT | O_EXCL | O_EXLOCK) for
 434          * local filesystems.  See vn_open_cred() for reciprocal part.
 435          */
 436         mp = vp->v_mount;
 437         if (mp != NULL && (mp->mnt_flag & MNT_LOCAL) != 0 &&
 438             ap->a_op == F_SETLK && (ap->a_flags & F_FIRSTOPEN) == 0) {
 439                 VI_LOCK(vp);
 440                 while ((vp->v_iflag & VI_FOPENING) != 0)
 441                         msleep(vp, VI_MTX(vp), PLOCK, "lockfo", 0);
 442                 VI_UNLOCK(vp);
 443         }
 444
 445         if (ap->a_fl->l_whence == SEEK_END) {
 446                 /*
 447                  * The NFSv4 server must avoid doing a vn_lock() here, since it
 448                  * can deadlock the nfsd threads, due to a LOR.  Fortunately
 449                  * the NFSv4 server always uses SEEK_SET and this code is
 450                  * only required for the SEEK_END case.
 451                  */
 452                 vn_lock(vp, LK_SHARED | LK_RETRY);
 453                 error = VOP_GETATTR(vp, &vattr, curthread->td_ucred);
 454                 VOP_UNLOCK(vp);
 455                 if (error)
 456                         return (error);
 457         } else
 458                 vattr.va_size = 0;
 459
 460         return (lf_advlock(ap, &(vp->v_lockf), vattr.va_size));
 461 }
 462
 463 int
 464 vop_stdadvlockasync(struct vop_advlockasync_args *ap)
 465 {
 466         struct vnode *vp;
 467         struct vattr vattr;
 468         int error;
 469
 470         vp = ap->a_vp;
 471         if (ap->a_fl->l_whence == SEEK_END) {
 472                 /* The size argument is only needed for SEEK_END. */
 473                 vn_lock(vp, LK_SHARED | LK_RETRY);
 474                 error = VOP_GETATTR(vp, &vattr, curthread->td_ucred);
 475                 VOP_UNLOCK(vp);
 476                 if (error)
 477                         return (error);
 478         } else
 479                 vattr.va_size = 0;
 480
 481         return (lf_advlockasync(ap, &(vp->v_lockf), vattr.va_size));
 482 }
 483
 484 int
 485 vop_stdadvlockpurge(struct vop_advlockpurge_args *ap)
 486 {
 487         struct vnode *vp;
 488
 489         vp = ap->a_vp;
 490         lf_purgelocks(vp, &vp->v_lockf);
 491         return (0);
 492 }
 493
 494 /*
 495  * vop_stdpathconf:
 496  *
 497  * Standard implementation of POSIX pathconf, to get information about limits
 498  * for a filesystem.
 499  * Override per filesystem for the case where the filesystem has smaller
 500  * limits.
 501  */
 502 int
 503 vop_stdpathconf(ap)
 504         struct vop_pathconf_args /* {
 505         struct vnode *a_vp;
 506         int a_name;
 507         int *a_retval;
 508         } */ *ap;
 509 {
 510
 511         switch (ap->a_name) {
 512                 case _PC_ASYNC_IO:
 513                         *ap->a_retval = _POSIX_ASYNCHRONOUS_IO;
 514                         return (0);
 515                 case _PC_PATH_MAX:
 516                         *ap->a_retval = PATH_MAX;
 517                         return (0);
 518                 case _PC_ACL_EXTENDED:
 519                 case _PC_ACL_NFS4:
 520                 case _PC_CAP_PRESENT:
 521                 case _PC_INF_PRESENT:
 522                 case _PC_MAC_PRESENT:
 523                         *ap->a_retval = 0;
 524                         return (0);
 525                 default:
 526                         return (EINVAL);
 527         }
 528         /* NOTREACHED */
 529 }
 530
 531 /*
 532  * Standard lock, unlock and islocked functions.
 533  */
 534 int
 535 vop_stdlock(ap)
 536         struct vop_lock1_args /* {
 537                 struct vnode *a_vp;
 538                 int a_flags;
 539                 char *file;
 540                 int line;
 541         } */ *ap;
 542 {
 543         struct vnode *vp = ap->a_vp;
 544         struct mtx *ilk;
 545
 546         ilk = VI_MTX(vp);
 547         return (lockmgr_lock_flags(vp->v_vnlock, ap->a_flags,
 548             &ilk->lock_object, ap->a_file, ap->a_line));
 549 }
 550
 551 /* See above. */
 552 int
 553 vop_stdunlock(ap)
 554         struct vop_unlock_args /* {
 555                 struct vnode *a_vp;
 556         } */ *ap;
 557 {
 558         struct vnode *vp = ap->a_vp;
 559
 560         return (lockmgr_unlock(vp->v_vnlock));
 561 }
 562
 563 /* See above. */
 564 int
 565 vop_stdislocked(ap)
 566         struct vop_islocked_args /* {
 567                 struct vnode *a_vp;
 568         } */ *ap;
 569 {
 570
 571         return (lockstatus(ap->a_vp->v_vnlock));
 572 }
 573
 574 /*
 575  * Variants of the above set.
 576  *
 577  * Differences are:
 578  * - shared locking disablement is not supported
 579  * - v_vnlock pointer is not honored
 580  */
 581 int
 582 vop_lock(ap)
 583         struct vop_lock1_args /* {
 584                 struct vnode *a_vp;
 585                 int a_flags;
 586                 char *file;
 587                 int line;
 588         } */ *ap;
 589 {
 590         struct vnode *vp = ap->a_vp;
 591         int flags = ap->a_flags;
 592         struct mtx *ilk;
 593
 594         MPASS(vp->v_vnlock == &vp->v_lock);
 595
 596         if (__predict_false((flags & ~(LK_TYPE_MASK | LK_NODDLKTREAT | LK_RETRY)) != 0))
 597                 goto other;
 598
 599         switch (flags & LK_TYPE_MASK) {
 600         case LK_SHARED:
 601                 return (lockmgr_slock(&vp->v_lock, flags, ap->a_file, ap->a_line));
 602         case LK_EXCLUSIVE:
 603                 return (lockmgr_xlock(&vp->v_lock, flags, ap->a_file, ap->a_line));
 604         }
 605 other:
 606         ilk = VI_MTX(vp);
 607         return (lockmgr_lock_flags(&vp->v_lock, flags,
 608             &ilk->lock_object, ap->a_file, ap->a_line));
 609 }
 610
 611 int
 612 vop_unlock(ap)
 613         struct vop_unlock_args /* {
 614                 struct vnode *a_vp;
 615         } */ *ap;
 616 {
 617         struct vnode *vp = ap->a_vp;
 618
 619         MPASS(vp->v_vnlock == &vp->v_lock);
 620
 621         return (lockmgr_unlock(&vp->v_lock));
 622 }
 623
 624 int
 625 vop_islocked(ap)
 626         struct vop_islocked_args /* {
 627                 struct vnode *a_vp;
 628         } */ *ap;
 629 {
 630         struct vnode *vp = ap->a_vp;
 631
 632         MPASS(vp->v_vnlock == &vp->v_lock);
 633
 634         return (lockstatus(&vp->v_lock));
 635 }
 636
 637 /*
 638  * Return true for select/poll.
 639  */
 640 int
 641 vop_nopoll(ap)
 642         struct vop_poll_args /* {
 643                 struct vnode *a_vp;
 644                 int  a_events;
 645                 struct ucred *a_cred;
 646                 struct thread *a_td;
 647         } */ *ap;
 648 {
 649
 650         if (ap->a_events & ~POLLSTANDARD)
 651                 return (POLLNVAL);
 652         return (ap->a_events & (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM));
 653 }
 654
 655 /*
 656  * Implement poll for local filesystems that support it.
 657  */
 658 int
 659 vop_stdpoll(ap)
 660         struct vop_poll_args /* {
 661                 struct vnode *a_vp;
 662                 int  a_events;
 663                 struct ucred *a_cred;
 664                 struct thread *a_td;
 665         } */ *ap;
 666 {
 667         if (ap->a_events & ~POLLSTANDARD)
 668                 return (vn_pollrecord(ap->a_vp, ap->a_td, ap->a_events));
 669         return (ap->a_events & (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM));
 670 }
 671
 672 /*
 673  * Return our mount point, as we will take charge of the writes.
 674  */
 675 int
 676 vop_stdgetwritemount(ap)
 677         struct vop_getwritemount_args /* {
 678                 struct vnode *a_vp;
 679                 struct mount **a_mpp;
 680         } */ *ap;
 681 {
 682         struct mount *mp;
 683         struct vnode *vp;
 684
 685         /*
 686          * Note that having a reference does not prevent forced unmount from
 687          * setting ->v_mount to NULL after the lock gets released. This is of
 688          * no consequence for typical consumers (most notably vn_start_write)
 689          * since in this case the vnode is VIRF_DOOMED. Unmount might have
 690          * progressed far enough that its completion is only delayed by the
 691          * reference obtained here. The consumer only needs to concern itself
 692          * with releasing it.
 693          */
 694         vp = ap->a_vp;
 695         mp = vfs_ref_from_vp(vp);
 696         *(ap->a_mpp) = mp;
 697         return (0);
 698 }
 699
 700 /*
 701  * If the file system doesn't implement VOP_BMAP, then return sensible defaults:
 702  * - Return the vnode's bufobj instead of any underlying device's bufobj
 703  * - Calculate the physical block number as if there were equal size
 704  *   consecutive blocks, but
 705  * - Report no contiguous runs of blocks.
 706  */
 707 int
 708 vop_stdbmap(ap)
 709         struct vop_bmap_args /* {
 710                 struct vnode *a_vp;
 711                 daddr_t  a_bn;
 712                 struct bufobj **a_bop;
 713                 daddr_t *a_bnp;
 714                 int *a_runp;
 715                 int *a_runb;
 716         } */ *ap;
 717 {
 718
 719         if (ap->a_bop != NULL)
 720                 *ap->a_bop = &ap->a_vp->v_bufobj;
 721         if (ap->a_bnp != NULL)
 722                 *ap->a_bnp = ap->a_bn * btodb(ap->a_vp->v_mount->mnt_stat.f_iosize);
 723         if (ap->a_runp != NULL)
 724                 *ap->a_runp = 0;
 725         if (ap->a_runb != NULL)
 726                 *ap->a_runb = 0;
 727         return (0);
 728 }
 729
 730 int
 731 vop_stdfsync(ap)
 732         struct vop_fsync_args /* {
 733                 struct vnode *a_vp;
 734                 int a_waitfor;
 735                 struct thread *a_td;
 736         } */ *ap;
 737 {
 738
 739         return (vn_fsync_buf(ap->a_vp, ap->a_waitfor));
 740 }
 741
 742 static int
 743 vop_stdfdatasync(struct vop_fdatasync_args *ap)
 744 {
 745
 746         return (VOP_FSYNC(ap->a_vp, MNT_WAIT, ap->a_td));
 747 }
 748
 749 int
 750 vop_stdfdatasync_buf(struct vop_fdatasync_args *ap)
 751 {
 752
 753         return (vn_fsync_buf(ap->a_vp, MNT_WAIT));
 754 }
 755
 756 /* XXX Needs good comment and more info in the manpage (VOP_GETPAGES(9)). */
 757 int
 758 vop_stdgetpages(ap)
 759         struct vop_getpages_args /* {
 760                 struct vnode *a_vp;
 761                 vm_page_t *a_m;
 762                 int a_count;
 763                 int *a_rbehind;
 764                 int *a_rahead;
 765         } */ *ap;
 766 {
 767
 768         return vnode_pager_generic_getpages(ap->a_vp, ap->a_m,
 769             ap->a_count, ap->a_rbehind, ap->a_rahead, NULL, NULL);
 770 }
 771
 772 static int
 773 vop_stdgetpages_async(struct vop_getpages_async_args *ap)
 774 {
 775         int error;
 776
 777         error = VOP_GETPAGES(ap->a_vp, ap->a_m, ap->a_count, ap->a_rbehind,
 778             ap->a_rahead);
 779         if (ap->a_iodone != NULL)
 780                 ap->a_iodone(ap->a_arg, ap->a_m, ap->a_count, error);
 781         return (error);
 782 }
 783
 784 int
 785 vop_stdkqfilter(struct vop_kqfilter_args *ap)
 786 {
 787         return vfs_kqfilter(ap);
 788 }
 789
 790 /* XXX Needs good comment and more info in the manpage (VOP_PUTPAGES(9)). */
 791 int
 792 vop_stdputpages(ap)
 793         struct vop_putpages_args /* {
 794                 struct vnode *a_vp;
 795                 vm_page_t *a_m;
 796                 int a_count;
 797                 int a_sync;
 798                 int *a_rtvals;
 799         } */ *ap;
 800 {
 801
 802         return vnode_pager_generic_putpages(ap->a_vp, ap->a_m, ap->a_count,
 803              ap->a_sync, ap->a_rtvals);
 804 }
 805
 806 int
 807 vop_stdvptofh(struct vop_vptofh_args *ap)
 808 {
 809         return (EOPNOTSUPP);
 810 }
 811
 812 int
 813 vop_stdvptocnp(struct vop_vptocnp_args *ap)
 814 {
 815         struct vnode *vp = ap->a_vp;
 816         struct vnode **dvp = ap->a_vpp;
 817         struct ucred *cred;
 818         char *buf = ap->a_buf;
 819         size_t *buflen = ap->a_buflen;
 820         char *dirbuf, *cpos;
 821         int i, error, eofflag, dirbuflen, flags, locked, len, covered;
 822         off_t off;
 823         ino_t fileno;
 824         struct vattr va;
 825         struct nameidata nd;
 826         struct thread *td;
 827         struct dirent *dp;
 828         struct vnode *mvp;
 829
 830         i = *buflen;
 831         error = 0;
 832         covered = 0;
 833         td = curthread;
 834         cred = td->td_ucred;
 835
 836         if (vp->v_type != VDIR)
 837                 return (ENOENT);
 838
 839         error = VOP_GETATTR(vp, &va, cred);
 840         if (error)
 841                 return (error);
 842
 843         VREF(vp);
 844         locked = VOP_ISLOCKED(vp);
 845         VOP_UNLOCK(vp);
 846         NDINIT_ATVP(&nd, LOOKUP, FOLLOW | LOCKSHARED | LOCKLEAF, UIO_SYSSPACE,
 847             "..", vp, td);
 848         flags = FREAD;
 849         error = vn_open_cred(&nd, &flags, 0, VN_OPEN_NOAUDIT, cred, NULL);
 850         if (error) {
 851                 vn_lock(vp, locked | LK_RETRY);
 852                 return (error);
 853         }
 854         NDFREE(&nd, NDF_ONLY_PNBUF);
 855
 856         mvp = *dvp = nd.ni_vp;
 857
 858         if (vp->v_mount != (*dvp)->v_mount &&
 859             ((*dvp)->v_vflag & VV_ROOT) &&
 860             ((*dvp)->v_mount->mnt_flag & MNT_UNION)) {
 861                 *dvp = (*dvp)->v_mount->mnt_vnodecovered;
 862                 VREF(mvp);
 863                 VOP_UNLOCK(mvp);
 864                 vn_close(mvp, FREAD, cred, td);
 865                 VREF(*dvp);
 866                 vn_lock(*dvp, LK_SHARED | LK_RETRY);
 867                 covered = 1;
 868         }
 869
 870         fileno = va.va_fileid;
 871
 872         dirbuflen = DEV_BSIZE;
 873         if (dirbuflen < va.va_blocksize)
 874                 dirbuflen = va.va_blocksize;
 875         dirbuf = (char *)malloc(dirbuflen, M_TEMP, M_WAITOK);
 876
 877         if ((*dvp)->v_type != VDIR) {
 878                 error = ENOENT;
 879                 goto out;
 880         }
 881
 882         off = 0;
 883         len = 0;
 884         do {
 885                 /* call VOP_READDIR of parent */
 886                 error = get_next_dirent(*dvp, &dp, dirbuf, dirbuflen, &off,
 887                                         &cpos, &len, &eofflag, td);
 888                 if (error)
 889                         goto out;
 890
 891                 if ((dp->d_type != DT_WHT) &&
 892                     (dp->d_fileno == fileno)) {
 893                         if (covered) {
 894                                 VOP_UNLOCK(*dvp);
 895                                 vn_lock(mvp, LK_SHARED | LK_RETRY);
 896                                 if (dirent_exists(mvp, dp->d_name, td)) {
 897                                         error = ENOENT;
 898                                         VOP_UNLOCK(mvp);
 899                                         vn_lock(*dvp, LK_SHARED | LK_RETRY);
 900                                         goto out;
 901                                 }
 902                                 VOP_UNLOCK(mvp);
 903                                 vn_lock(*dvp, LK_SHARED | LK_RETRY);
 904                         }
 905                         i -= dp->d_namlen;
 906
 907                         if (i < 0) {
 908                                 error = ENOMEM;
 909                                 goto out;
 910                         }
 911                         if (dp->d_namlen == 1 && dp->d_name[0] == '.') {
 912                                 error = ENOENT;
 913                         } else {
 914                                 bcopy(dp->d_name, buf + i, dp->d_namlen);
 915                                 error = 0;
 916                         }
 917                         goto out;
 918                 }
 919         } while (len > 0 || !eofflag);
 920         error = ENOENT;
 921
 922 out:
 923         free(dirbuf, M_TEMP);
 924         if (!error) {
 925                 *buflen = i;
 926                 vref(*dvp);
 927         }
 928         if (covered) {
 929                 vput(*dvp);
 930                 vrele(mvp);
 931         } else {
 932                 VOP_UNLOCK(mvp);
 933                 vn_close(mvp, FREAD, cred, td);
 934         }
 935         vn_lock(vp, locked | LK_RETRY);
 936         return (error);
 937 }
 938
 939 int
 940 vop_stdallocate(struct vop_allocate_args *ap)
 941 {
 942 #ifdef __notyet__
 943         struct statfs *sfs;
 944         off_t maxfilesize = 0;
 945 #endif
 946         struct iovec aiov;
 947         struct vattr vattr, *vap;
 948         struct uio auio;
 949         off_t fsize, len, cur, offset;
 950         uint8_t *buf;
 951         struct thread *td;
 952         struct vnode *vp;
 953         size_t iosize;
 954         int error;
 955
 956         buf = NULL;
 957         error = 0;
 958         td = curthread;
 959         vap = &vattr;
 960         vp = ap->a_vp;
 961         len = *ap->a_len;
 962         offset = *ap->a_offset;
 963
 964         error = VOP_GETATTR(vp, vap, ap->a_cred);
 965         if (error != 0)
 966                 goto out;
 967         fsize = vap->va_size;
 968         iosize = vap->va_blocksize;
 969         if (iosize == 0)
 970                 iosize = BLKDEV_IOSIZE;
 971         if (iosize > maxphys)
 972                 iosize = maxphys;
 973         buf = malloc(iosize, M_TEMP, M_WAITOK);
 974
 975 #ifdef __notyet__
 976         /*
 977          * Check if the filesystem sets f_maxfilesize; if not use
 978          * VOP_SETATTR to perform the check.
 979          */
 980         sfs = malloc(sizeof(struct statfs), M_STATFS, M_WAITOK);
 981         error = VFS_STATFS(vp->v_mount, sfs, td);
 982         if (error == 0)
 983                 maxfilesize = sfs->f_maxfilesize;
 984         free(sfs, M_STATFS);
 985         if (error != 0)
 986                 goto out;
 987         if (maxfilesize) {
 988                 if (offset > maxfilesize || len > maxfilesize ||
 989                     offset + len > maxfilesize) {
 990                         error = EFBIG;
 991                         goto out;
 992                 }
 993         } else
 994 #endif
 995         if (offset + len > vap->va_size) {
 996                 /*
 997                  * Test offset + len against the filesystem's maxfilesize.
 998                  */
 999                 VATTR_NULL(vap);
1000                 vap->va_size = offset + len;
1001                 error = VOP_SETATTR(vp, vap, ap->a_cred);
1002                 if (error != 0)
1003                         goto out;
1004                 VATTR_NULL(vap);
1005                 vap->va_size = fsize;
1006                 error = VOP_SETATTR(vp, vap, ap->a_cred);
1007                 if (error != 0)
1008                         goto out;
1009         }
1010
1011         for (;;) {
1012                 /*
1013                  * Read and write back anything below the nominal file
1014                  * size.  There's currently no way outside the filesystem
1015                  * to know whether this area is sparse or not.
1016                  */
1017                 cur = iosize;
1018                 if ((offset % iosize) != 0)
1019                         cur -= (offset % iosize);
1020                 if (cur > len)
1021                         cur = len;
1022                 if (offset < fsize) {
1023                         aiov.iov_base = buf;
1024                         aiov.iov_len = cur;
1025                         auio.uio_iov = &aiov;
1026                         auio.uio_iovcnt = 1;
1027                         auio.uio_offset = offset;
1028                         auio.uio_resid = cur;
1029                         auio.uio_segflg = UIO_SYSSPACE;
1030                         auio.uio_rw = UIO_READ;
1031                         auio.uio_td = td;
1032                         error = VOP_READ(vp, &auio, ap->a_ioflag, ap->a_cred);
1033                         if (error != 0)
1034                                 break;
1035                         if (auio.uio_resid > 0) {
1036                                 bzero(buf + cur - auio.uio_resid,
1037                                     auio.uio_resid);
1038                         }
1039                 } else {
1040                         bzero(buf, cur);
1041                 }
1042
1043                 aiov.iov_base = buf;
1044                 aiov.iov_len = cur;
1045                 auio.uio_iov = &aiov;
1046                 auio.uio_iovcnt = 1;
1047                 auio.uio_offset = offset;
1048                 auio.uio_resid = cur;
1049                 auio.uio_segflg = UIO_SYSSPACE;
1050                 auio.uio_rw = UIO_WRITE;
1051                 auio.uio_td = td;
1052
1053                 error = VOP_WRITE(vp, &auio, ap->a_ioflag, ap->a_cred);
1054                 if (error != 0)
1055                         break;
1056
1057                 len -= cur;
1058                 offset += cur;
1059                 if (len == 0)
1060                         break;
1061                 if (should_yield())
1062                         break;
1063         }
1064
1065  out:
1066         *ap->a_len = len;
1067         *ap->a_offset = offset;
1068         free(buf, M_TEMP);
1069         return (error);
1070 }
1071
1072 int
1073 vop_stdadvise(struct vop_advise_args *ap)
1074 {
1075         struct vnode *vp;
1076         struct bufobj *bo;
1077         daddr_t startn, endn;
1078         off_t bstart, bend, start, end;
1079         int bsize, error;
1080
1081         vp = ap->a_vp;
1082         switch (ap->a_advice) {
1083         case POSIX_FADV_WILLNEED:
1084                 /*
1085                  * Do nothing for now.  Filesystems should provide a
1086                  * custom method which starts an asynchronous read of
1087                  * the requested region.
1088                  */
1089                 error = 0;
1090                 break;
1091         case POSIX_FADV_DONTNEED:
1092                 error = 0;
1093                 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
1094                 if (VN_IS_DOOMED(vp)) {
1095                         VOP_UNLOCK(vp);
1096                         break;
1097                 }
1098
1099                 /*
1100                  * Round to block boundaries (and later possibly further to
1101                  * page boundaries).  Applications cannot reasonably be aware
1102                  * of the boundaries, and the rounding must be to expand at
1103                  * both extremities to cover enough.  It still doesn't cover
1104                  * read-ahead.  For partial blocks, this gives unnecessary
1105                  * discarding of buffers but is efficient enough since the
1106                  * pages usually remain in VMIO for some time.
1107                  */
1108                 bsize = vp->v_bufobj.bo_bsize;
1109                 bstart = rounddown(ap->a_start, bsize);
1110                 bend = roundup(ap->a_end, bsize);
1111
1112                 /*
1113                  * Deactivate pages in the specified range from the backing VM
1114                  * object.  Pages that are resident in the buffer cache will
1115                  * remain wired until their corresponding buffers are released
1116                  * below.
1117                  */
1118                 if (vp->v_object != NULL) {
1119                         start = trunc_page(bstart);
1120                         end = round_page(bend);
1121                         VM_OBJECT_RLOCK(vp->v_object);
1122                         vm_object_page_noreuse(vp->v_object, OFF_TO_IDX(start),
1123                             OFF_TO_IDX(end));
1124                         VM_OBJECT_RUNLOCK(vp->v_object);
1125                 }
1126
1127                 bo = &vp->v_bufobj;
1128                 BO_RLOCK(bo);
1129                 startn = bstart / bsize;
1130                 endn = bend / bsize;
1131                 error = bnoreuselist(&bo->bo_clean, bo, startn, endn);
1132                 if (error == 0)
1133                         error = bnoreuselist(&bo->bo_dirty, bo, startn, endn);
1134                 BO_RUNLOCK(bo);
1135                 VOP_UNLOCK(vp);
1136                 break;
1137         default:
1138                 error = EINVAL;
1139                 break;
1140         }
1141         return (error);
1142 }
1143
1144 int
1145 vop_stdunp_bind(struct vop_unp_bind_args *ap)
1146 {
1147
1148         ap->a_vp->v_unpcb = ap->a_unpcb;
1149         return (0);
1150 }
1151
1152 int
1153 vop_stdunp_connect(struct vop_unp_connect_args *ap)
1154 {
1155
1156         *ap->a_unpcb = ap->a_vp->v_unpcb;
1157         return (0);
1158 }
1159
1160 int
1161 vop_stdunp_detach(struct vop_unp_detach_args *ap)
1162 {
1163
1164         ap->a_vp->v_unpcb = NULL;
1165         return (0);
1166 }
1167
1168 static int
1169 vop_stdis_text(struct vop_is_text_args *ap)
1170 {
1171
1172         return (ap->a_vp->v_writecount < 0);
1173 }
1174
1175 int
1176 vop_stdset_text(struct vop_set_text_args *ap)
1177 {
1178         struct vnode *vp;
1179         struct mount *mp;
1180         int error, n;
1181
1182         vp = ap->a_vp;
1183
1184         /*
1185          * Avoid the interlock if execs are already present.
1186          */
1187         n = atomic_load_int(&vp->v_writecount);
1188         for (;;) {
1189                 if (n > -1) {
1190                         break;
1191                 }
1192                 if (atomic_fcmpset_int(&vp->v_writecount, &n, n - 1)) {
1193                         return (0);
1194                 }
1195         }
1196
1197         VI_LOCK(vp);
1198         if (vp->v_writecount > 0) {
1199                 error = ETXTBSY;
1200         } else {
1201                 /*
1202                  * If requested by fs, keep a use reference to the
1203                  * vnode until the last text reference is released.
1204                  */
1205                 mp = vp->v_mount;
1206                 if (mp != NULL && (mp->mnt_kern_flag & MNTK_TEXT_REFS) != 0 &&
1207                     vp->v_writecount == 0) {
1208                         VNPASS((vp->v_iflag & VI_TEXT_REF) == 0, vp);
1209                         vp->v_iflag |= VI_TEXT_REF;
1210                         vrefl(vp);
1211                 }
1212
1213                 atomic_subtract_int(&vp->v_writecount, 1);
1214                 error = 0;
1215         }
1216         VI_UNLOCK(vp);
1217         return (error);
1218 }
1219
1220 static int
1221 vop_stdunset_text(struct vop_unset_text_args *ap)
1222 {
1223         struct vnode *vp;
1224         int error, n;
1225         bool last;
1226
1227         vp = ap->a_vp;
1228
1229         /*
1230          * Avoid the interlock if this is not the last exec.
1231          */
1232         n = atomic_load_int(&vp->v_writecount);
1233         for (;;) {
1234                 if (n >= -1) {
1235                         break;
1236                 }
1237                 if (atomic_fcmpset_int(&vp->v_writecount, &n, n + 1)) {
1238                         return (0);
1239                 }
1240         }
1241
1242         last = false;
1243         VI_LOCK(vp);
1244         if (vp->v_writecount < 0) {
1245                 if ((vp->v_iflag & VI_TEXT_REF) != 0 &&
1246                     vp->v_writecount == -1) {
1247                         last = true;
1248                         vp->v_iflag &= ~VI_TEXT_REF;
1249                 }
1250                 atomic_add_int(&vp->v_writecount, 1);
1251                 error = 0;
1252         } else {
1253                 error = EINVAL;
1254         }
1255         VI_UNLOCK(vp);
1256         if (last)
1257                 vunref(vp);
1258         return (error);
1259 }
1260
1261 static int
1262 vop_stdadd_writecount(struct vop_add_writecount_args *ap)
1263 {
1264         struct vnode *vp;
1265         struct mount *mp;
1266         int error;
1267
1268         vp = ap->a_vp;
1269         VI_LOCK_FLAGS(vp, MTX_DUPOK);
1270         if (vp->v_writecount < 0) {
1271                 error = ETXTBSY;
1272         } else {
1273                 VNASSERT(vp->v_writecount + ap->a_inc >= 0, vp,
1274                     ("neg writecount increment %d", ap->a_inc));
1275                 if (vp->v_writecount == 0) {
1276                         mp = vp->v_mount;
1277                         if (mp != NULL && (mp->mnt_kern_flag & MNTK_NOMSYNC) == 0)
1278                                 vlazy(vp);
1279                 }
1280                 vp->v_writecount += ap->a_inc;
1281                 error = 0;
1282         }
1283         VI_UNLOCK(vp);
1284         return (error);
1285 }
1286
1287 int
1288 vop_stdneed_inactive(struct vop_need_inactive_args *ap)
1289 {
1290
1291         return (1);
1292 }
1293
1294 int
1295 vop_stdioctl(struct vop_ioctl_args *ap)
1296 {
1297         struct vnode *vp;
1298         struct vattr va;
1299         off_t *offp;
1300         int error;
1301
1302         switch (ap->a_command) {
1303         case FIOSEEKDATA:
1304         case FIOSEEKHOLE:
1305                 vp = ap->a_vp;
1306                 error = vn_lock(vp, LK_SHARED);
1307                 if (error != 0)
1308                         return (EBADF);
1309                 if (vp->v_type == VREG)
1310                         error = VOP_GETATTR(vp, &va, ap->a_cred);
1311                 else
1312                         error = ENOTTY;
1313                 if (error == 0) {
1314                         offp = ap->a_data;
1315                         if (*offp < 0 || *offp >= va.va_size)
1316                                 error = ENXIO;
1317                         else if (ap->a_command == FIOSEEKHOLE)
1318                                 *offp = va.va_size;
1319                 }
1320                 VOP_UNLOCK(vp);
1321                 break;
1322         default:
1323                 error = ENOTTY;
1324                 break;
1325         }
1326         return (error);
1327 }
1328
1329 /*
1330  * vfs default ops
1331  * used to fill the vfs function table to get reasonable default return values.
1332  */
1333 int
1334 vfs_stdroot (mp, flags, vpp)
1335         struct mount *mp;
1336         int flags;
1337         struct vnode **vpp;
1338 {
1339
1340         return (EOPNOTSUPP);
1341 }
1342
1343 int
1344 vfs_stdstatfs (mp, sbp)
1345         struct mount *mp;
1346         struct statfs *sbp;
1347 {
1348
1349         return (EOPNOTSUPP);
1350 }
1351
1352 int
1353 vfs_stdquotactl (mp, cmds, uid, arg)
1354         struct mount *mp;
1355         int cmds;
1356         uid_t uid;
1357         void *arg;
1358 {
1359
1360         return (EOPNOTSUPP);
1361 }
1362
1363 int
1364 vfs_stdsync(mp, waitfor)
1365         struct mount *mp;
1366         int waitfor;
1367 {
1368         struct vnode *vp, *mvp;
1369         struct thread *td;
1370         int error, lockreq, allerror = 0;
1371
1372         td = curthread;
1373         lockreq = LK_EXCLUSIVE | LK_INTERLOCK;
1374         if (waitfor != MNT_WAIT)
1375                 lockreq |= LK_NOWAIT;
1376         /*
1377          * Force stale buffer cache information to be flushed.
1378          */
1379 loop:
1380         MNT_VNODE_FOREACH_ALL(vp, mp, mvp) {
1381                 if (vp->v_bufobj.bo_dirty.bv_cnt == 0) {
1382                         VI_UNLOCK(vp);
1383                         continue;
1384                 }
1385                 if ((error = vget(vp, lockreq)) != 0) {
1386                         if (error == ENOENT) {
1387                                 MNT_VNODE_FOREACH_ALL_ABORT(mp, mvp);
1388                                 goto loop;
1389                         }
1390                         continue;
1391                 }
1392                 error = VOP_FSYNC(vp, waitfor, td);
1393                 if (error)
1394                         allerror = error;
1395                 vput(vp);
1396         }
1397         return (allerror);
1398 }
1399
1400 int
1401 vfs_stdnosync (mp, waitfor)
1402         struct mount *mp;
1403         int waitfor;
1404 {
1405
1406         return (0);
1407 }
1408
1409 static int
1410 vop_stdcopy_file_range(struct vop_copy_file_range_args *ap)
1411 {
1412         int error;
1413
1414         error = vn_generic_copy_file_range(ap->a_invp, ap->a_inoffp,
1415             ap->a_outvp, ap->a_outoffp, ap->a_lenp, ap->a_flags, ap->a_incred,
1416             ap->a_outcred, ap->a_fsizetd);
1417         return (error);
1418 }
1419
1420 int
1421 vfs_stdvget (mp, ino, flags, vpp)
1422         struct mount *mp;
1423         ino_t ino;
1424         int flags;
1425         struct vnode **vpp;
1426 {
1427
1428         return (EOPNOTSUPP);
1429 }
1430
1431 int
1432 vfs_stdfhtovp (mp, fhp, flags, vpp)
1433         struct mount *mp;
1434         struct fid *fhp;
1435         int flags;
1436         struct vnode **vpp;
1437 {
1438
1439         return (EOPNOTSUPP);
1440 }
1441
1442 int
1443 vfs_stdinit (vfsp)
1444         struct vfsconf *vfsp;
1445 {
1446
1447         return (0);
1448 }
1449
1450 int
1451 vfs_stduninit (vfsp)
1452         struct vfsconf *vfsp;
1453 {
1454
1455         return(0);
1456 }
1457
1458 int
1459 vfs_stdextattrctl(mp, cmd, filename_vp, attrnamespace, attrname)
1460         struct mount *mp;
1461         int cmd;
1462         struct vnode *filename_vp;
1463         int attrnamespace;
1464         const char *attrname;
1465 {
1466
1467         if (filename_vp != NULL)
1468                 VOP_UNLOCK(filename_vp);
1469         return (EOPNOTSUPP);
1470 }
1471
1472 int
1473 vfs_stdsysctl(mp, op, req)
1474         struct mount *mp;
1475         fsctlop_t op;
1476         struct sysctl_req *req;
1477 {
1478
1479         return (EOPNOTSUPP);
1480 }
1481
1482 static vop_bypass_t *
1483 bp_by_off(struct vop_vector *vop, struct vop_generic_args *a)
1484 {
1485
1486         return (*(vop_bypass_t **)((char *)vop + a->a_desc->vdesc_vop_offset));
1487 }
1488
1489 int
1490 vop_sigdefer(struct vop_vector *vop, struct vop_generic_args *a)
1491 {
1492         vop_bypass_t *bp;
1493         int prev_stops, rc;
1494
1495         bp = bp_by_off(vop, a);
1496         MPASS(bp != NULL);
1497
1498         prev_stops = sigdeferstop(SIGDEFERSTOP_SILENT);
1499         rc = bp(a);
1500         sigallowstop(prev_stops);
1501         return (rc);
1502 }
1503
1504 static int
1505 vop_stdstat(struct vop_stat_args *a)
1506 {
1507         struct vattr vattr;
1508         struct vattr *vap;
1509         struct vnode *vp;
1510         struct stat *sb;
1511         int error;
1512         u_short mode;
1513
1514         vp = a->a_vp;
1515         sb = a->a_sb;
1516
1517         error = vop_stat_helper_pre(a);
1518         if (error != 0)
1519                 return (error);
1520
1521         vap = &vattr;
1522
1523         /*
1524          * Initialize defaults for new and unusual fields, so that file
1525          * systems which don't support these fields don't need to know
1526          * about them.
1527          */
1528         vap->va_birthtime.tv_sec = -1;
1529         vap->va_birthtime.tv_nsec = 0;
1530         vap->va_fsid = VNOVAL;
1531         vap->va_rdev = NODEV;
1532
1533         error = VOP_GETATTR(vp, vap, a->a_active_cred);
1534         if (error)
1535                 goto out;
1536
1537         /*
1538          * Zero the spare stat fields
1539          */
1540         bzero(sb, sizeof *sb);
1541
1542         /*
1543          * Copy from vattr table
1544          */
1545         if (vap->va_fsid != VNOVAL)
1546                 sb->st_dev = vap->va_fsid;
1547         else
1548                 sb->st_dev = vp->v_mount->mnt_stat.f_fsid.val[0];
1549         sb->st_ino = vap->va_fileid;
1550         mode = vap->va_mode;
1551         switch (vap->va_type) {
1552         case VREG:
1553                 mode |= S_IFREG;
1554                 break;
1555         case VDIR:
1556                 mode |= S_IFDIR;
1557                 break;
1558         case VBLK:
1559                 mode |= S_IFBLK;
1560                 break;
1561         case VCHR:
1562                 mode |= S_IFCHR;
1563                 break;
1564         case VLNK:
1565                 mode |= S_IFLNK;
1566                 break;
1567         case VSOCK:
1568                 mode |= S_IFSOCK;
1569                 break;
1570         case VFIFO:
1571                 mode |= S_IFIFO;
1572                 break;
1573         default:
1574                 error = EBADF;
1575                 goto out;
1576         }
1577         sb->st_mode = mode;
1578         sb->st_nlink = vap->va_nlink;
1579         sb->st_uid = vap->va_uid;
1580         sb->st_gid = vap->va_gid;
1581         sb->st_rdev = vap->va_rdev;
1582         if (vap->va_size > OFF_MAX) {
1583                 error = EOVERFLOW;
1584                 goto out;
1585         }
1586         sb->st_size = vap->va_size;
1587         sb->st_atim.tv_sec = vap->va_atime.tv_sec;
1588         sb->st_atim.tv_nsec = vap->va_atime.tv_nsec;
1589         sb->st_mtim.tv_sec = vap->va_mtime.tv_sec;
1590         sb->st_mtim.tv_nsec = vap->va_mtime.tv_nsec;
1591         sb->st_ctim.tv_sec = vap->va_ctime.tv_sec;
1592         sb->st_ctim.tv_nsec = vap->va_ctime.tv_nsec;
1593         sb->st_birthtim.tv_sec = vap->va_birthtime.tv_sec;
1594         sb->st_birthtim.tv_nsec = vap->va_birthtime.tv_nsec;
1595
1596         /*
1597          * According to www.opengroup.org, the meaning of st_blksize is
1598          *   "a filesystem-specific preferred I/O block size for this
1599          *    object.  In some filesystem types, this may vary from file
1600          *    to file"
1601          * Use minimum/default of PAGE_SIZE (e.g. for VCHR).
1602          */
1603
1604         sb->st_blksize = max(PAGE_SIZE, vap->va_blocksize);
1605         sb->st_flags = vap->va_flags;
1606         sb->st_blocks = vap->va_bytes / S_BLKSIZE;
1607         sb->st_gen = vap->va_gen;
1608 out:
1609         return (vop_stat_helper_post(a, error));
1610 }
1611
1612 static int
1613 vop_stdread_pgcache(struct vop_read_pgcache_args *ap __unused)
1614 {
1615         return (EJUSTRETURN);
1616 }
1617
1618 static int
1619 vop_stdvput_pair(struct vop_vput_pair_args *ap)
1620 {
1621         struct vnode *dvp, *vp, **vpp;
1622
1623         dvp = ap->a_dvp;
1624         vpp = ap->a_vpp;
1625         vput(dvp);
1626         if (vpp != NULL && ap->a_unlock_vp && (vp = *vpp) != NULL)
1627                 vput(vp);
1628         return (0);
1629 }