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/event.h>
  44 #include <sys/kernel.h>
  45 #include <sys/limits.h>
  46 #include <sys/lock.h>
  47 #include <sys/malloc.h>
  48 #include <sys/mount.h>
  49 #include <sys/mutex.h>
  50 #include <sys/unistd.h>
  51 #include <sys/vnode.h>
  52 #include <sys/poll.h>
  53
  54 #include <vm/vm.h>
  55 #include <vm/vm_object.h>
  56 #include <vm/vm_extern.h>
  57 #include <vm/pmap.h>
  58 #include <vm/vm_map.h>
  59 #include <vm/vm_page.h>
  60 #include <vm/vm_pager.h>
  61 #include <vm/vnode_pager.h>
  62
  63 static int      vop_nolookup(struct vop_lookup_args *);
  64 static int      vop_nostrategy(struct vop_strategy_args *);
  65
  66 /*
  67  * This vnode table stores what we want to do if the filesystem doesn't
  68  * implement a particular VOP.
  69  *
  70  * If there is no specific entry here, we will return EOPNOTSUPP.
  71  *
  72  */
  73
  74 struct vop_vector default_vnodeops = {
  75         .vop_default =          NULL,
  76         .vop_bypass =           VOP_EOPNOTSUPP,
  77
  78         .vop_advlock =          VOP_EINVAL,
  79         .vop_bmap =             vop_stdbmap,
  80         .vop_close =            VOP_NULL,
  81         .vop_fsync =            VOP_NULL,
  82         .vop_getpages =         vop_stdgetpages,
  83         .vop_getwritemount =    vop_stdgetwritemount,
  84         .vop_inactive =         VOP_NULL,
  85         .vop_ioctl =            VOP_ENOTTY,
  86         .vop_kqfilter =         vop_stdkqfilter,
  87         .vop_islocked =         vop_stdislocked,
  88         .vop_lease =            VOP_NULL,
  89         .vop_lock =             vop_stdlock,
  90         .vop_lookup =           vop_nolookup,
  91         .vop_open =             VOP_NULL,
  92         .vop_pathconf =         VOP_EINVAL,
  93         .vop_poll =             vop_nopoll,
  94         .vop_putpages =         vop_stdputpages,
  95         .vop_readlink =         VOP_EINVAL,
  96         .vop_revoke =           VOP_PANIC,
  97         .vop_strategy =         vop_nostrategy,
  98         .vop_unlock =           vop_stdunlock,
  99 };
 100
 101 /*
 102  * Series of placeholder functions for various error returns for
 103  * VOPs.
 104  */
 105
 106 int
 107 vop_eopnotsupp(struct vop_generic_args *ap)
 108 {
 109         /*
 110         printf("vop_notsupp[%s]\n", ap->a_desc->vdesc_name);
 111         */
 112
 113         return (EOPNOTSUPP);
 114 }
 115
 116 int
 117 vop_ebadf(struct vop_generic_args *ap)
 118 {
 119
 120         return (EBADF);
 121 }
 122
 123 int
 124 vop_enotty(struct vop_generic_args *ap)
 125 {
 126
 127         return (ENOTTY);
 128 }
 129
 130 int
 131 vop_einval(struct vop_generic_args *ap)
 132 {
 133
 134         return (EINVAL);
 135 }
 136
 137 int
 138 vop_null(struct vop_generic_args *ap)
 139 {
 140
 141         return (0);
 142 }
 143
 144 /*
 145  * Helper function to panic on some bad VOPs in some filesystems.
 146  */
 147 int
 148 vop_panic(struct vop_generic_args *ap)
 149 {
 150
 151         panic("filesystem goof: vop_panic[%s]", ap->a_desc->vdesc_name);
 152 }
 153
 154 /*
 155  * vop_std<something> and vop_no<something> are default functions for use by
 156  * filesystems that need the "default reasonable" implementation for a
 157  * particular operation.
 158  *
 159  * The documentation for the operations they implement exists (if it exists)
 160  * in the VOP_<SOMETHING>(9) manpage (all uppercase).
 161  */
 162
 163 /*
 164  * Default vop for filesystems that do not support name lookup
 165  */
 166 static int
 167 vop_nolookup(ap)
 168         struct vop_lookup_args /* {
 169                 struct vnode *a_dvp;
 170                 struct vnode **a_vpp;
 171                 struct componentname *a_cnp;
 172         } */ *ap;
 173 {
 174
 175         *ap->a_vpp = NULL;
 176         return (ENOTDIR);
 177 }
 178
 179 /*
 180  *      vop_nostrategy:
 181  *
 182  *      Strategy routine for VFS devices that have none.
 183  *
 184  *      BIO_ERROR and B_INVAL must be cleared prior to calling any strategy
 185  *      routine.  Typically this is done for a BIO_READ strategy call.
 186  *      Typically B_INVAL is assumed to already be clear prior to a write
 187  *      and should not be cleared manually unless you just made the buffer
 188  *      invalid.  BIO_ERROR should be cleared either way.
 189  */
 190
 191 static int
 192 vop_nostrategy (struct vop_strategy_args *ap)
 193 {
 194         printf("No strategy for buffer at %p\n", ap->a_bp);
 195         vprint("vnode", ap->a_vp);
 196         ap->a_bp->b_ioflags |= BIO_ERROR;
 197         ap->a_bp->b_error = EOPNOTSUPP;
 198         bufdone(ap->a_bp);
 199         return (EOPNOTSUPP);
 200 }
 201
 202 /*
 203  * vop_stdpathconf:
 204  *
 205  * Standard implementation of POSIX pathconf, to get information about limits
 206  * for a filesystem.
 207  * Override per filesystem for the case where the filesystem has smaller
 208  * limits.
 209  */
 210 int
 211 vop_stdpathconf(ap)
 212         struct vop_pathconf_args /* {
 213         struct vnode *a_vp;
 214         int a_name;
 215         int *a_retval;
 216         } */ *ap;
 217 {
 218
 219         switch (ap->a_name) {
 220                 case _PC_LINK_MAX:
 221                         *ap->a_retval = LINK_MAX;
 222                         return (0);
 223                 case _PC_MAX_CANON:
 224                         *ap->a_retval = MAX_CANON;
 225                         return (0);
 226                 case _PC_MAX_INPUT:
 227                         *ap->a_retval = MAX_INPUT;
 228                         return (0);
 229                 case _PC_PIPE_BUF:
 230                         *ap->a_retval = PIPE_BUF;
 231                         return (0);
 232                 case _PC_CHOWN_RESTRICTED:
 233                         *ap->a_retval = 1;
 234                         return (0);
 235                 case _PC_VDISABLE:
 236                         *ap->a_retval = _POSIX_VDISABLE;
 237                         return (0);
 238                 default:
 239                         return (EINVAL);
 240         }
 241         /* NOTREACHED */
 242 }
 243
 244 /*
 245  * Standard lock, unlock and islocked functions.
 246  */
 247 int
 248 vop_stdlock(ap)
 249         struct vop_lock_args /* {
 250                 struct vnode *a_vp;
 251                 int a_flags;
 252                 struct thread *a_td;
 253         } */ *ap;
 254 {
 255         struct vnode *vp = ap->a_vp;
 256
 257 #ifndef DEBUG_LOCKS
 258         return (lockmgr(vp->v_vnlock, ap->a_flags, VI_MTX(vp), ap->a_td));
 259 #else
 260         return (debuglockmgr(vp->v_vnlock, ap->a_flags, VI_MTX(vp),
 261             ap->a_td, "vop_stdlock", vp->filename, vp->line));
 262 #endif
 263 }
 264
 265 /* See above. */
 266 int
 267 vop_stdunlock(ap)
 268         struct vop_unlock_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         return (lockmgr(vp->v_vnlock, ap->a_flags | LK_RELEASE, VI_MTX(vp),
 277             ap->a_td));
 278 }
 279
 280 /* See above. */
 281 int
 282 vop_stdislocked(ap)
 283         struct vop_islocked_args /* {
 284                 struct vnode *a_vp;
 285                 struct thread *a_td;
 286         } */ *ap;
 287 {
 288
 289         return (lockstatus(ap->a_vp->v_vnlock, ap->a_td));
 290 }
 291
 292 /*
 293  * Return true for select/poll.
 294  */
 295 int
 296 vop_nopoll(ap)
 297         struct vop_poll_args /* {
 298                 struct vnode *a_vp;
 299                 int  a_events;
 300                 struct ucred *a_cred;
 301                 struct thread *a_td;
 302         } */ *ap;
 303 {
 304         /*
 305          * Return true for read/write.  If the user asked for something
 306          * special, return POLLNVAL, so that clients have a way of
 307          * determining reliably whether or not the extended
 308          * functionality is present without hard-coding knowledge
 309          * of specific filesystem implementations.
 310          * Stay in sync with kern_conf.c::no_poll().
 311          */
 312         if (ap->a_events & ~POLLSTANDARD)
 313                 return (POLLNVAL);
 314
 315         return (ap->a_events & (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM));
 316 }
 317
 318 /*
 319  * Implement poll for local filesystems that support it.
 320  */
 321 int
 322 vop_stdpoll(ap)
 323         struct vop_poll_args /* {
 324                 struct vnode *a_vp;
 325                 int  a_events;
 326                 struct ucred *a_cred;
 327                 struct thread *a_td;
 328         } */ *ap;
 329 {
 330         if (ap->a_events & ~POLLSTANDARD)
 331                 return (vn_pollrecord(ap->a_vp, ap->a_td, ap->a_events));
 332         return (ap->a_events & (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM));
 333 }
 334
 335 /*
 336  * Return our mount point, as we will take charge of the writes.
 337  */
 338 int
 339 vop_stdgetwritemount(ap)
 340         struct vop_getwritemount_args /* {
 341                 struct vnode *a_vp;
 342                 struct mount **a_mpp;
 343         } */ *ap;
 344 {
 345
 346         *(ap->a_mpp) = ap->a_vp->v_mount;
 347         return (0);
 348 }
 349
 350 /* XXX Needs good comment and VOP_BMAP(9) manpage */
 351 int
 352 vop_stdbmap(ap)
 353         struct vop_bmap_args /* {
 354                 struct vnode *a_vp;
 355                 daddr_t  a_bn;
 356                 struct bufobj **a_bop;
 357                 daddr_t *a_bnp;
 358                 int *a_runp;
 359                 int *a_runb;
 360         } */ *ap;
 361 {
 362
 363         if (ap->a_bop != NULL)
 364                 *ap->a_bop = &ap->a_vp->v_bufobj;
 365         if (ap->a_bnp != NULL)
 366                 *ap->a_bnp = ap->a_bn * btodb(ap->a_vp->v_mount->mnt_stat.f_iosize);
 367         if (ap->a_runp != NULL)
 368                 *ap->a_runp = 0;
 369         if (ap->a_runb != NULL)
 370                 *ap->a_runb = 0;
 371         return (0);
 372 }
 373
 374 int
 375 vop_stdfsync(ap)
 376         struct vop_fsync_args /* {
 377                 struct vnode *a_vp;
 378                 struct ucred *a_cred;
 379                 int a_waitfor;
 380                 struct thread *a_td;
 381         } */ *ap;
 382 {
 383         struct vnode *vp = ap->a_vp;
 384         struct buf *bp;
 385         struct bufobj *bo;
 386         struct buf *nbp;
 387         int error = 0;
 388         int maxretry = 1000;     /* large, arbitrarily chosen */
 389
 390         VI_LOCK(vp);
 391 loop1:
 392         /*
 393          * MARK/SCAN initialization to avoid infinite loops.
 394          */
 395         TAILQ_FOREACH(bp, &vp->v_bufobj.bo_dirty.bv_hd, b_bobufs) {
 396                 bp->b_vflags &= ~BV_SCANNED;
 397                 bp->b_error = 0;
 398         }
 399
 400         /*
 401          * Flush all dirty buffers associated with a vnode.
 402          */
 403 loop2:
 404         TAILQ_FOREACH_SAFE(bp, &vp->v_bufobj.bo_dirty.bv_hd, b_bobufs, nbp) {
 405                 if ((bp->b_vflags & BV_SCANNED) != 0)
 406                         continue;
 407                 bp->b_vflags |= BV_SCANNED;
 408                 if (BUF_LOCK(bp, LK_EXCLUSIVE | LK_NOWAIT, NULL))
 409                         continue;
 410                 VI_UNLOCK(vp);
 411                 if ((bp->b_flags & B_DELWRI) == 0)
 412                         panic("fsync: not dirty");
 413                 if ((vp->v_object != NULL) && (bp->b_flags & B_CLUSTEROK)) {
 414                         vfs_bio_awrite(bp);
 415                 } else {
 416                         bremfree(bp);
 417                         bawrite(bp);
 418                 }
 419                 VI_LOCK(vp);
 420                 goto loop2;
 421         }
 422
 423         /*
 424          * If synchronous the caller expects us to completely resolve all
 425          * dirty buffers in the system.  Wait for in-progress I/O to
 426          * complete (which could include background bitmap writes), then
 427          * retry if dirty blocks still exist.
 428          */
 429         if (ap->a_waitfor == MNT_WAIT) {
 430                 bo = &vp->v_bufobj;
 431                 bufobj_wwait(bo, 0, 0);
 432                 if (bo->bo_dirty.bv_cnt > 0) {
 433                         /*
 434                          * If we are unable to write any of these buffers
 435                          * then we fail now rather than trying endlessly
 436                          * to write them out.
 437                          */
 438                         TAILQ_FOREACH(bp, &bo->bo_dirty.bv_hd, b_bobufs)
 439                                 if ((error = bp->b_error) == 0)
 440                                         continue;
 441                         if (error == 0 && --maxretry >= 0)
 442                                 goto loop1;
 443                         error = EAGAIN;
 444                 }
 445         }
 446         VI_UNLOCK(vp);
 447         if (error == EAGAIN)
 448                 vprint("fsync: giving up on dirty", vp);
 449
 450         return (error);
 451 }
 452
 453 /* XXX Needs good comment and more info in the manpage (VOP_GETPAGES(9)). */
 454 int
 455 vop_stdgetpages(ap)
 456         struct vop_getpages_args /* {
 457                 struct vnode *a_vp;
 458                 vm_page_t *a_m;
 459                 int a_count;
 460                 int a_reqpage;
 461                 vm_ooffset_t a_offset;
 462         } */ *ap;
 463 {
 464
 465         return vnode_pager_generic_getpages(ap->a_vp, ap->a_m,
 466             ap->a_count, ap->a_reqpage);
 467 }
 468
 469 int
 470 vop_stdkqfilter(struct vop_kqfilter_args *ap)
 471 {
 472         return vfs_kqfilter(ap);
 473 }
 474
 475 /* XXX Needs good comment and more info in the manpage (VOP_PUTPAGES(9)). */
 476 int
 477 vop_stdputpages(ap)
 478         struct vop_putpages_args /* {
 479                 struct vnode *a_vp;
 480                 vm_page_t *a_m;
 481                 int a_count;
 482                 int a_sync;
 483                 int *a_rtvals;
 484                 vm_ooffset_t a_offset;
 485         } */ *ap;
 486 {
 487
 488         return vnode_pager_generic_putpages(ap->a_vp, ap->a_m, ap->a_count,
 489              ap->a_sync, ap->a_rtvals);
 490 }
 491
 492 /*
 493  * vfs default ops
 494  * used to fill the vfs function table to get reasonable default return values.
 495  */
 496 int
 497 vfs_stdroot (mp, flags, vpp, td)
 498         struct mount *mp;
 499         int flags;
 500         struct vnode **vpp;
 501         struct thread *td;
 502 {
 503
 504         return (EOPNOTSUPP);
 505 }
 506
 507 int
 508 vfs_stdstatfs (mp, sbp, td)
 509         struct mount *mp;
 510         struct statfs *sbp;
 511         struct thread *td;
 512 {
 513
 514         return (EOPNOTSUPP);
 515 }
 516
 517 int
 518 vfs_stdvptofh (vp, fhp)
 519         struct vnode *vp;
 520         struct fid *fhp;
 521 {
 522
 523         return (EOPNOTSUPP);
 524 }
 525
 526 int
 527 vfs_stdquotactl (mp, cmds, uid, arg, td)
 528         struct mount *mp;
 529         int cmds;
 530         uid_t uid;
 531         caddr_t arg;
 532         struct thread *td;
 533 {
 534
 535         return (EOPNOTSUPP);
 536 }
 537
 538 int
 539 vfs_stdsync(mp, waitfor, td)
 540         struct mount *mp;
 541         int waitfor;
 542         struct thread *td;
 543 {
 544         struct vnode *vp, *nvp;
 545         int error, lockreq, allerror = 0;
 546
 547         lockreq = LK_EXCLUSIVE | LK_INTERLOCK;
 548         if (waitfor != MNT_WAIT)
 549                 lockreq |= LK_NOWAIT;
 550         /*
 551          * Force stale buffer cache information to be flushed.
 552          */
 553         MNT_ILOCK(mp);
 554 loop:
 555         MNT_VNODE_FOREACH(vp, mp, nvp) {
 556
 557                 VI_LOCK(vp);
 558                 if (vp->v_bufobj.bo_dirty.bv_cnt == 0) {
 559                         VI_UNLOCK(vp);
 560                         continue;
 561                 }
 562                 MNT_IUNLOCK(mp);
 563
 564                 if ((error = vget(vp, lockreq, td)) != 0) {
 565                         MNT_ILOCK(mp);
 566                         if (error == ENOENT)
 567                                 goto loop;
 568                         continue;
 569                 }
 570                 error = VOP_FSYNC(vp, waitfor, td);
 571                 if (error)
 572                         allerror = error;
 573
 574                 VOP_UNLOCK(vp, 0, td);
 575                 vrele(vp);
 576                 MNT_ILOCK(mp);
 577         }
 578         MNT_IUNLOCK(mp);
 579         return (allerror);
 580 }
 581
 582 int
 583 vfs_stdnosync (mp, waitfor, td)
 584         struct mount *mp;
 585         int waitfor;
 586         struct thread *td;
 587 {
 588
 589         return (0);
 590 }
 591
 592 int
 593 vfs_stdvget (mp, ino, flags, vpp)
 594         struct mount *mp;
 595         ino_t ino;
 596         int flags;
 597         struct vnode **vpp;
 598 {
 599
 600         return (EOPNOTSUPP);
 601 }
 602
 603 int
 604 vfs_stdfhtovp (mp, fhp, vpp)
 605         struct mount *mp;
 606         struct fid *fhp;
 607         struct vnode **vpp;
 608 {
 609
 610         return (EOPNOTSUPP);
 611 }
 612
 613 int
 614 vfs_stdinit (vfsp)
 615         struct vfsconf *vfsp;
 616 {
 617
 618         return (0);
 619 }
 620
 621 int
 622 vfs_stduninit (vfsp)
 623         struct vfsconf *vfsp;
 624 {
 625
 626         return(0);
 627 }
 628
 629 int
 630 vfs_stdextattrctl(mp, cmd, filename_vp, attrnamespace, attrname, td)
 631         struct mount *mp;
 632         int cmd;
 633         struct vnode *filename_vp;
 634         int attrnamespace;
 635         const char *attrname;
 636         struct thread *td;
 637 {
 638
 639         if (filename_vp != NULL)
 640                 VOP_UNLOCK(filename_vp, 0, td);
 641         return (EOPNOTSUPP);
 642 }
 643
 644 int
 645 vfs_stdsysctl(mp, op, req)
 646         struct mount *mp;
 647         fsctlop_t op;
 648         struct sysctl_req *req;
 649 {
 650
 651         return (EOPNOTSUPP);
 652 }
 653
 654 /* end of vfs default ops */