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