sys/kern/vfs_default.c

   1 /*
   2  * Copyright (c) 1989, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * This code is derived from software contributed
   6  * to Berkeley by John Heidemann of the UCLA Ficus project.
   7  *
   8  * Source: * @(#)i405_init.c 2.10 92/04/27 UCLA Ficus project
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  * 4. Neither the name of the University nor the names of its contributors
  19  *    may be used to endorse or promote products derived from this software
  20  *    without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  */
  34
  35 #include <sys/cdefs.h>
  36 __FBSDID("$FreeBSD$");
  37
  38 #include <sys/param.h>
  39 #include <sys/systm.h>
  40 #include <sys/bio.h>
  41 #include <sys/buf.h>
  42 #include <sys/conf.h>
  43 #include <sys/kernel.h>
  44 #include <sys/limits.h>
  45 #include <sys/lock.h>
  46 #include <sys/malloc.h>
  47 #include <sys/mount.h>
  48 #include <sys/mutex.h>
  49 #include <sys/unistd.h>
  50 #include <sys/vnode.h>
  51 #include <sys/poll.h>
  52
  53 #include <vm/vm.h>
  54 #include <vm/vm_object.h>
  55 #include <vm/vm_extern.h>
  56 #include <vm/pmap.h>
  57 #include <vm/vm_map.h>
  58 #include <vm/vm_page.h>
  59 #include <vm/vm_pager.h>
  60 #include <vm/vnode_pager.h>
  61
  62 static int      vop_nolookup(struct vop_lookup_args *);
  63 static int      vop_nostrategy(struct vop_strategy_args *);
  64
  65 /*
  66  * This vnode table stores what we want to do if the filesystem doesn't
  67  * implement a particular VOP.
  68  *
  69  * If there is no specific entry here, we will return EOPNOTSUPP.
  70  *
  71  */
  72
  73 vop_t **default_vnodeop_p;
  74 static struct vnodeopv_entry_desc default_vnodeop_entries[] = {
  75         { &vop_default_desc,            (vop_t *) vop_eopnotsupp },
  76         { &vop_advlock_desc,            (vop_t *) vop_einval },
  77         { &vop_bmap_desc,               (vop_t *) vop_stdbmap },
  78         { &vop_close_desc,              (vop_t *) vop_null },
  79         { &vop_createvobject_desc,      (vop_t *) vop_stdcreatevobject },
  80         { &vop_destroyvobject_desc,     (vop_t *) vop_stddestroyvobject },
  81         { &vop_fsync_desc,              (vop_t *) vop_null },
  82         { &vop_getpages_desc,           (vop_t *) vop_stdgetpages },
  83         { &vop_getvobject_desc,         (vop_t *) vop_stdgetvobject },
  84         { &vop_inactive_desc,           (vop_t *) vop_stdinactive },
  85         { &vop_ioctl_desc,              (vop_t *) vop_enotty },
  86         { &vop_islocked_desc,           (vop_t *) vop_stdislocked },
  87         { &vop_lease_desc,              (vop_t *) vop_null },
  88         { &vop_lock_desc,               (vop_t *) vop_stdlock },
  89         { &vop_lookup_desc,             (vop_t *) vop_nolookup },
  90         { &vop_open_desc,               (vop_t *) vop_null },
  91         { &vop_pathconf_desc,           (vop_t *) vop_einval },
  92         { &vop_poll_desc,               (vop_t *) vop_nopoll },
  93         { &vop_putpages_desc,           (vop_t *) vop_stdputpages },
  94         { &vop_readlink_desc,           (vop_t *) vop_einval },
  95         { &vop_revoke_desc,             (vop_t *) vop_revoke },
  96         { &vop_specstrategy_desc,       (vop_t *) vop_panic },
  97         { &vop_strategy_desc,           (vop_t *) vop_nostrategy },
  98         { &vop_unlock_desc,             (vop_t *) vop_stdunlock },
  99         { NULL, NULL }
 100 };
 101
 102 static struct vnodeopv_desc default_vnodeop_opv_desc =
 103         { &default_vnodeop_p, default_vnodeop_entries };
 104
 105 VNODEOP_SET(default_vnodeop_opv_desc);
 106
 107 /*
 108  * Series of placeholder functions for various error returns for
 109  * VOPs.
 110  */
 111
 112 int
 113 vop_eopnotsupp(struct vop_generic_args *ap)
 114 {
 115         /*
 116         printf("vop_notsupp[%s]\n", ap->a_desc->vdesc_name);
 117         */
 118
 119         return (EOPNOTSUPP);
 120 }
 121
 122 int
 123 vop_ebadf(struct vop_generic_args *ap)
 124 {
 125
 126         return (EBADF);
 127 }
 128
 129 int
 130 vop_enotty(struct vop_generic_args *ap)
 131 {
 132
 133         return (ENOTTY);
 134 }
 135
 136 int
 137 vop_einval(struct vop_generic_args *ap)
 138 {
 139
 140         return (EINVAL);
 141 }
 142
 143 int
 144 vop_null(struct vop_generic_args *ap)
 145 {
 146
 147         return (0);
 148 }
 149
 150 /*
 151  * Used to make a defined VOP fall back to the default VOP.
 152  */
 153 int
 154 vop_defaultop(struct vop_generic_args *ap)
 155 {
 156
 157         return (VOCALL(default_vnodeop_p, ap->a_desc->vdesc_offset, ap));
 158 }
 159
 160 /*
 161  * Helper function to panic on some bad VOPs in some filesystems.
 162  */
 163 int
 164 vop_panic(struct vop_generic_args *ap)
 165 {
 166
 167         panic("filesystem goof: vop_panic[%s]", ap->a_desc->vdesc_name);
 168 }
 169
 170 /*
 171  * vop_std<something> and vop_no<something> are default functions for use by
 172  * filesystems that need the "default reasonable" implementation for a
 173  * particular operation.
 174  *
 175  * The documentation for the operations they implement exists (if it exists)
 176  * in the VOP_<SOMETHING>(9) manpage (all uppercase).
 177  */
 178
 179 /*
 180  * Default vop for filesystems that do not support name lookup
 181  */
 182 static int
 183 vop_nolookup(ap)
 184         struct vop_lookup_args /* {
 185                 struct vnode *a_dvp;
 186                 struct vnode **a_vpp;
 187                 struct componentname *a_cnp;
 188         } */ *ap;
 189 {
 190
 191         *ap->a_vpp = NULL;
 192         return (ENOTDIR);
 193 }
 194
 195 /*
 196  *      vop_nostrategy:
 197  *
 198  *      Strategy routine for VFS devices that have none.
 199  *
 200  *      BIO_ERROR and B_INVAL must be cleared prior to calling any strategy
 201  *      routine.  Typically this is done for a BIO_READ strategy call.
 202  *      Typically B_INVAL is assumed to already be clear prior to a write
 203  *      and should not be cleared manually unless you just made the buffer
 204  *      invalid.  BIO_ERROR should be cleared either way.
 205  */
 206
 207 static int
 208 vop_nostrategy (struct vop_strategy_args *ap)
 209 {
 210         KASSERT(ap->a_vp == ap->a_bp->b_vp, ("%s(%p != %p)",
 211             __func__, ap->a_vp, ap->a_bp->b_vp));
 212         printf("No strategy for buffer at %p\n", ap->a_bp);
 213         vprint("vnode", ap->a_vp);
 214         vprint("device vnode", ap->a_bp->b_vp);
 215         ap->a_bp->b_ioflags |= BIO_ERROR;
 216         ap->a_bp->b_error = EOPNOTSUPP;
 217         bufdone(ap->a_bp);
 218         return (EOPNOTSUPP);
 219 }
 220
 221 /*
 222  * vop_stdpathconf:
 223  *
 224  * Standard implementation of POSIX pathconf, to get information about limits
 225  * for a filesystem.
 226  * Override per filesystem for the case where the filesystem has smaller
 227  * limits.
 228  */
 229 int
 230 vop_stdpathconf(ap)
 231         struct vop_pathconf_args /* {
 232         struct vnode *a_vp;
 233         int a_name;
 234         int *a_retval;
 235         } */ *ap;
 236 {
 237
 238         switch (ap->a_name) {
 239                 case _PC_LINK_MAX:
 240                         *ap->a_retval = LINK_MAX;
 241                         return (0);
 242                 case _PC_MAX_CANON:
 243                         *ap->a_retval = MAX_CANON;
 244                         return (0);
 245                 case _PC_MAX_INPUT:
 246                         *ap->a_retval = MAX_INPUT;
 247                         return (0);
 248                 case _PC_PIPE_BUF:
 249                         *ap->a_retval = PIPE_BUF;
 250                         return (0);
 251                 case _PC_CHOWN_RESTRICTED:
 252                         *ap->a_retval = 1;
 253                         return (0);
 254                 case _PC_VDISABLE:
 255                         *ap->a_retval = _POSIX_VDISABLE;
 256                         return (0);
 257                 default:
 258                         return (EINVAL);
 259         }
 260         /* NOTREACHED */
 261 }
 262
 263 /*
 264  * Standard lock, unlock and islocked functions.
 265  */
 266 int
 267 vop_stdlock(ap)
 268         struct vop_lock_args /* {
 269                 struct vnode *a_vp;
 270                 int a_flags;
 271                 struct thread *a_td;
 272         } */ *ap;
 273 {
 274         struct vnode *vp = ap->a_vp;
 275
 276 #ifndef DEBUG_LOCKS
 277         return (lockmgr(vp->v_vnlock, ap->a_flags, VI_MTX(vp), ap->a_td));
 278 #else
 279         return (debuglockmgr(vp->v_vnlock, ap->a_flags, VI_MTX(vp),
 280             ap->a_td, "vop_stdlock", vp->filename, vp->line));
 281 #endif
 282 }
 283
 284 /* See above. */
 285 int
 286 vop_stdunlock(ap)
 287         struct vop_unlock_args /* {
 288                 struct vnode *a_vp;
 289                 int a_flags;
 290                 struct thread *a_td;
 291         } */ *ap;
 292 {
 293         struct vnode *vp = ap->a_vp;
 294
 295         return (lockmgr(vp->v_vnlock, ap->a_flags | LK_RELEASE, VI_MTX(vp),
 296             ap->a_td));
 297 }
 298
 299 /* See above. */
 300 int
 301 vop_stdislocked(ap)
 302         struct vop_islocked_args /* {
 303                 struct vnode *a_vp;
 304                 struct thread *a_td;
 305         } */ *ap;
 306 {
 307
 308         return (lockstatus(ap->a_vp->v_vnlock, ap->a_td));
 309 }
 310
 311 /* Mark the vnode inactive */
 312 int
 313 vop_stdinactive(ap)
 314         struct vop_inactive_args /* {
 315                 struct vnode *a_vp;
 316                 struct thread *a_td;
 317         } */ *ap;
 318 {
 319
 320         VOP_UNLOCK(ap->a_vp, 0, ap->a_td);
 321         return (0);
 322 }
 323
 324 /*
 325  * Return true for select/poll.
 326  */
 327 int
 328 vop_nopoll(ap)
 329         struct vop_poll_args /* {
 330                 struct vnode *a_vp;
 331                 int  a_events;
 332                 struct ucred *a_cred;
 333                 struct thread *a_td;
 334         } */ *ap;
 335 {
 336         /*
 337          * Return true for read/write.  If the user asked for something
 338          * special, return POLLNVAL, so that clients have a way of
 339          * determining reliably whether or not the extended
 340          * functionality is present without hard-coding knowledge
 341          * of specific filesystem implementations.
 342          * Stay in sync with kern_conf.c::no_poll().
 343          */
 344         if (ap->a_events & ~POLLSTANDARD)
 345                 return (POLLNVAL);
 346
 347         return (ap->a_events & (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM));
 348 }
 349
 350 /*
 351  * Implement poll for local filesystems that support it.
 352  */
 353 int
 354 vop_stdpoll(ap)
 355         struct vop_poll_args /* {
 356                 struct vnode *a_vp;
 357                 int  a_events;
 358                 struct ucred *a_cred;
 359                 struct thread *a_td;
 360         } */ *ap;
 361 {
 362         if (ap->a_events & ~POLLSTANDARD)
 363                 return (vn_pollrecord(ap->a_vp, ap->a_td, ap->a_events));
 364         return (ap->a_events & (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM));
 365 }
 366
 367 /*
 368  * Return our mount point, as we will take charge of the writes.
 369  */
 370 int
 371 vop_stdgetwritemount(ap)
 372         struct vop_getwritemount_args /* {
 373                 struct vnode *a_vp;
 374                 struct mount **a_mpp;
 375         } */ *ap;
 376 {
 377
 378         *(ap->a_mpp) = ap->a_vp->v_mount;
 379         return (0);
 380 }
 381
 382 /* Create the VM system backing object for this vnode */
 383 int
 384 vop_stdcreatevobject(ap)
 385         struct vop_createvobject_args /* {
 386                 struct vnode *vp;
 387                 struct ucred *cred;
 388                 struct thread *td;
 389         } */ *ap;
 390 {
 391         struct vnode *vp = ap->a_vp;
 392         struct ucred *cred = ap->a_cred;
 393         struct thread *td = ap->a_td;
 394         struct vattr vat;
 395         vm_object_t object;
 396         int error = 0;
 397
 398         GIANT_REQUIRED;
 399
 400         if (!vn_isdisk(vp, NULL) && vn_canvmio(vp) == FALSE)
 401                 return (0);
 402
 403 retry:
 404         if ((object = vp->v_object) == NULL) {
 405                 if (vp->v_type == VREG || vp->v_type == VDIR) {
 406                         if ((error = VOP_GETATTR(vp, &vat, cred, td)) != 0)
 407                                 goto retn;
 408                         object = vnode_pager_alloc(vp, vat.va_size, 0, 0);
 409                 } else if (vn_isdisk(vp, NULL)) {
 410                         /*
 411                          * This simply allocates the biggest object possible
 412                          * for a disk vnode.  This should be fixed, but doesn't
 413                          * cause any problems (yet).
 414                          */
 415                         object = vnode_pager_alloc(vp, IDX_TO_OFF(INT_MAX), 0, 0);
 416                 } else {
 417                         goto retn;
 418                 }
 419                 /*
 420                  * Dereference the reference we just created.  This assumes
 421                  * that the object is associated with the vp.
 422                  */
 423                 VM_OBJECT_LOCK(object);
 424                 object->ref_count--;
 425                 VM_OBJECT_UNLOCK(object);
 426                 vrele(vp);
 427         } else {
 428                 VM_OBJECT_LOCK(object);
 429                 if (object->flags & OBJ_DEAD) {
 430                         VOP_UNLOCK(vp, 0, td);
 431                         msleep(object, VM_OBJECT_MTX(object), PDROP | PVM,
 432                             "vodead", 0);
 433                         vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
 434                         goto retry;
 435                 }
 436                 VM_OBJECT_UNLOCK(object);
 437         }
 438
 439         KASSERT(vp->v_object != NULL, ("vfs_object_create: NULL object"));
 440         vp->v_vflag |= VV_OBJBUF;
 441
 442 retn:
 443         return (error);
 444 }
 445
 446 /* Destroy the VM system object associated with this vnode */
 447 int
 448 vop_stddestroyvobject(ap)
 449         struct vop_destroyvobject_args /* {
 450                 struct vnode *vp;
 451         } */ *ap;
 452 {
 453         struct vnode *vp = ap->a_vp;
 454         vm_object_t obj = vp->v_object;
 455
 456         GIANT_REQUIRED;
 457
 458         if (obj == NULL)
 459                 return (0);
 460         VM_OBJECT_LOCK(obj);
 461         if (obj->ref_count == 0) {
 462                 /*
 463                  * vclean() may be called twice. The first time
 464                  * removes the primary reference to the object,
 465                  * the second time goes one further and is a
 466                  * special-case to terminate the object.
 467                  *
 468                  * don't double-terminate the object
 469                  */
 470                 if ((obj->flags & OBJ_DEAD) == 0)
 471                         vm_object_terminate(obj);
 472                 else
 473                         VM_OBJECT_UNLOCK(obj);
 474         } else {
 475                 /*
 476                  * Woe to the process that tries to page now :-).
 477                  */
 478                 vm_pager_deallocate(obj);
 479                 VM_OBJECT_UNLOCK(obj);
 480         }
 481         return (0);
 482 }
 483
 484 /*
 485  * Return the underlying VM object.  This routine may be called with or
 486  * without the vnode interlock held.  If called without, the returned
 487  * object is not guarenteed to be valid.  The syncer typically gets the
 488  * object without holding the interlock in order to quickly test whether
 489  * it might be dirty before going heavy-weight.  vm_object's use zalloc
 490  * and thus stable-storage, so this is safe.
 491  */
 492 int
 493 vop_stdgetvobject(ap)
 494         struct vop_getvobject_args /* {
 495                 struct vnode *vp;
 496                 struct vm_object **objpp;
 497         } */ *ap;
 498 {
 499         struct vnode *vp = ap->a_vp;
 500         struct vm_object **objpp = ap->a_objpp;
 501
 502         if (objpp)
 503                 *objpp = vp->v_object;
 504         return (vp->v_object ? 0 : EINVAL);
 505 }
 506
 507 /* XXX Needs good comment and VOP_BMAP(9) manpage */
 508 int
 509 vop_stdbmap(ap)
 510         struct vop_bmap_args /* {
 511                 struct vnode *a_vp;
 512                 daddr_t  a_bn;
 513                 struct vnode **a_vpp;
 514                 daddr_t *a_bnp;
 515                 int *a_runp;
 516                 int *a_runb;
 517         } */ *ap;
 518 {
 519
 520         if (ap->a_vpp != NULL)
 521                 *ap->a_vpp = ap->a_vp;
 522         if (ap->a_bnp != NULL)
 523                 *ap->a_bnp = ap->a_bn * btodb(ap->a_vp->v_mount->mnt_stat.f_iosize);
 524         if (ap->a_runp != NULL)
 525                 *ap->a_runp = 0;
 526         if (ap->a_runb != NULL)
 527                 *ap->a_runb = 0;
 528         return (0);
 529 }
 530
 531 int
 532 vop_stdfsync(ap)
 533         struct vop_fsync_args /* {
 534                 struct vnode *a_vp;
 535                 struct ucred *a_cred;
 536                 int a_waitfor;
 537                 struct thread *a_td;
 538         } */ *ap;
 539 {
 540         struct vnode *vp = ap->a_vp;
 541         struct buf *bp;
 542         struct buf *nbp;
 543         int s, error = 0;
 544         int maxretry = 100;     /* large, arbitrarily chosen */
 545
 546         VI_LOCK(vp);
 547 loop1:
 548         /*
 549          * MARK/SCAN initialization to avoid infinite loops.
 550          */
 551         s = splbio();
 552         TAILQ_FOREACH(bp, &vp->v_dirtyblkhd, b_vnbufs) {
 553                 bp->b_vflags &= ~BV_SCANNED;
 554                 bp->b_error = 0;
 555         }
 556         splx(s);
 557
 558         /*
 559          * Flush all dirty buffers associated with a block device.
 560          */
 561 loop2:
 562         s = splbio();
 563         for (bp = TAILQ_FIRST(&vp->v_dirtyblkhd); bp != NULL; bp = nbp) {
 564                 nbp = TAILQ_NEXT(bp, b_vnbufs);
 565                 if ((bp->b_vflags & BV_SCANNED) != 0)
 566                         continue;
 567                 bp->b_vflags |= BV_SCANNED;
 568                 if (BUF_LOCK(bp, LK_EXCLUSIVE | LK_NOWAIT, NULL))
 569                         continue;
 570                 VI_UNLOCK(vp);
 571                 if ((bp->b_flags & B_DELWRI) == 0)
 572                         panic("fsync: not dirty");
 573                 if ((vp->v_vflag & VV_OBJBUF) && (bp->b_flags & B_CLUSTEROK)) {
 574                         vfs_bio_awrite(bp);
 575                         splx(s);
 576                 } else {
 577                         bremfree(bp);
 578                         splx(s);
 579                         bawrite(bp);
 580                 }
 581                 VI_LOCK(vp);
 582                 goto loop2;
 583         }
 584
 585         /*
 586          * If synchronous the caller expects us to completely resolve all
 587          * dirty buffers in the system.  Wait for in-progress I/O to
 588          * complete (which could include background bitmap writes), then
 589          * retry if dirty blocks still exist.
 590          */
 591         if (ap->a_waitfor == MNT_WAIT) {
 592                 while (vp->v_numoutput) {
 593                         vp->v_iflag |= VI_BWAIT;
 594                         msleep((caddr_t)&vp->v_numoutput, VI_MTX(vp),
 595                             PRIBIO + 1, "fsync", 0);
 596                 }
 597                 if (!TAILQ_EMPTY(&vp->v_dirtyblkhd)) {
 598                         /*
 599                          * If we are unable to write any of these buffers
 600                          * then we fail now rather than trying endlessly
 601                          * to write them out.
 602                          */
 603                         TAILQ_FOREACH(bp, &vp->v_dirtyblkhd, b_vnbufs)
 604                                 if ((error = bp->b_error) == 0)
 605                                         continue;
 606                         if (error == 0 && --maxretry >= 0) {
 607                                 splx(s);
 608                                 goto loop1;
 609                         }
 610                         vprint("fsync: giving up on dirty", vp);
 611                         error = EAGAIN;
 612                 }
 613         }
 614         VI_UNLOCK(vp);
 615         splx(s);
 616
 617         return (error);
 618 }
 619
 620 /* XXX Needs good comment and more info in the manpage (VOP_GETPAGES(9)). */
 621 int
 622 vop_stdgetpages(ap)
 623         struct vop_getpages_args /* {
 624                 struct vnode *a_vp;
 625                 vm_page_t *a_m;
 626                 int a_count;
 627                 int a_reqpage;
 628                 vm_ooffset_t a_offset;
 629         } */ *ap;
 630 {
 631
 632         return vnode_pager_generic_getpages(ap->a_vp, ap->a_m,
 633             ap->a_count, ap->a_reqpage);
 634 }
 635
 636 /* XXX Needs good comment and more info in the manpage (VOP_PUTPAGES(9)). */
 637 int
 638 vop_stdputpages(ap)
 639         struct vop_putpages_args /* {
 640                 struct vnode *a_vp;
 641                 vm_page_t *a_m;
 642                 int a_count;
 643                 int a_sync;
 644                 int *a_rtvals;
 645                 vm_ooffset_t a_offset;
 646         } */ *ap;
 647 {
 648
 649         return vnode_pager_generic_putpages(ap->a_vp, ap->a_m, ap->a_count,
 650              ap->a_sync, ap->a_rtvals);
 651 }
 652
 653 /*
 654  * vfs default ops
 655  * used to fill the vfs function table to get reasonable default return values.
 656  */
 657 int
 658 vfs_stdroot (mp, vpp, td)
 659         struct mount *mp;
 660         struct vnode **vpp;
 661         struct thread *td;
 662 {
 663
 664         return (EOPNOTSUPP);
 665 }
 666
 667 int
 668 vfs_stdstatfs (mp, sbp, td)
 669         struct mount *mp;
 670         struct statfs *sbp;
 671         struct thread *td;
 672 {
 673
 674         return (EOPNOTSUPP);
 675 }
 676
 677 int
 678 vfs_stdvptofh (vp, fhp)
 679         struct vnode *vp;
 680         struct fid *fhp;
 681 {
 682
 683         return (EOPNOTSUPP);
 684 }
 685
 686 int
 687 vfs_stdstart (mp, flags, td)
 688         struct mount *mp;
 689         int flags;
 690         struct thread *td;
 691 {
 692
 693         return (0);
 694 }
 695
 696 int
 697 vfs_stdquotactl (mp, cmds, uid, arg, td)
 698         struct mount *mp;
 699         int cmds;
 700         uid_t uid;
 701         caddr_t arg;
 702         struct thread *td;
 703 {
 704
 705         return (EOPNOTSUPP);
 706 }
 707
 708 int
 709 vfs_stdsync(mp, waitfor, cred, td)
 710         struct mount *mp;
 711         int waitfor;
 712         struct ucred *cred;
 713         struct thread *td;
 714 {
 715         struct vnode *vp, *nvp;
 716         int error, lockreq, allerror = 0;
 717
 718         lockreq = LK_EXCLUSIVE | LK_INTERLOCK;
 719         if (waitfor != MNT_WAIT)
 720                 lockreq |= LK_NOWAIT;
 721         /*
 722          * Force stale buffer cache information to be flushed.
 723          */
 724         MNT_ILOCK(mp);
 725 loop:
 726         MNT_VNODE_FOREACH(vp, mp, nvp) {
 727
 728                 VI_LOCK(vp);
 729                 if (TAILQ_EMPTY(&vp->v_dirtyblkhd)) {
 730                         VI_UNLOCK(vp);
 731                         continue;
 732                 }
 733                 MNT_IUNLOCK(mp);
 734
 735                 if ((error = vget(vp, lockreq, td)) != 0) {
 736                         MNT_ILOCK(mp);
 737                         if (error == ENOENT)
 738                                 goto loop;
 739                         continue;
 740                 }
 741                 error = VOP_FSYNC(vp, cred, waitfor, td);
 742                 if (error)
 743                         allerror = error;
 744
 745                 VOP_UNLOCK(vp, 0, td);
 746                 vrele(vp);
 747                 MNT_ILOCK(mp);
 748         }
 749         MNT_IUNLOCK(mp);
 750         return (allerror);
 751 }
 752
 753 int
 754 vfs_stdnosync (mp, waitfor, cred, td)
 755         struct mount *mp;
 756         int waitfor;
 757         struct ucred *cred;
 758         struct thread *td;
 759 {
 760
 761         return (0);
 762 }
 763
 764 int
 765 vfs_stdvget (mp, ino, flags, vpp)
 766         struct mount *mp;
 767         ino_t ino;
 768         int flags;
 769         struct vnode **vpp;
 770 {
 771
 772         return (EOPNOTSUPP);
 773 }
 774
 775 int
 776 vfs_stdfhtovp (mp, fhp, vpp)
 777         struct mount *mp;
 778         struct fid *fhp;
 779         struct vnode **vpp;
 780 {
 781
 782         return (EOPNOTSUPP);
 783 }
 784
 785 int
 786 vfs_stdinit (vfsp)
 787         struct vfsconf *vfsp;
 788 {
 789
 790         return (0);
 791 }
 792
 793 int
 794 vfs_stduninit (vfsp)
 795         struct vfsconf *vfsp;
 796 {
 797
 798         return(0);
 799 }
 800
 801 int
 802 vfs_stdextattrctl(mp, cmd, filename_vp, attrnamespace, attrname, td)
 803         struct mount *mp;
 804         int cmd;
 805         struct vnode *filename_vp;
 806         int attrnamespace;
 807         const char *attrname;
 808         struct thread *td;
 809 {
 810
 811         if (filename_vp != NULL)
 812                 VOP_UNLOCK(filename_vp, 0, td);
 813         return (EOPNOTSUPP);
 814 }
 815
 816 int
 817 vfs_stdsysctl(mp, op, req)
 818         struct mount *mp;
 819         fsctlop_t op;
 820         struct sysctl_req *req;
 821 {
 822
 823         return (EOPNOTSUPP);
 824 }
 825
 826 /* end of vfs default ops */