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  * The statvfs->statfs conversion code was contributed to the DragonFly
   9  * Project by Joerg Sonnenberger <joerg@bec.de>.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  * 3. Neither the name of the University nor the names of its contributors
  20  *    may be used to endorse or promote products derived from this software
  21  *    without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  *
  35  * Source: * @(#)i405_init.c 2.10 92/04/27 UCLA Ficus project
  36  * $FreeBSD: src/sys/kern/vfs_default.c,v 1.28.2.7 2003/01/10 18:23:26 bde Exp $
  37  */
  38
  39 #include <sys/param.h>
  40 #include <sys/systm.h>
  41 #include <sys/buf.h>
  42 #include <sys/conf.h>
  43 #include <sys/fcntl.h>
  44 #include <sys/file.h>
  45 #include <sys/kernel.h>
  46 #include <sys/lock.h>
  47 #include <sys/malloc.h>
  48 #include <sys/mount.h>
  49 #include <sys/unistd.h>
  50 #include <sys/vnode.h>
  51 #include <sys/namei.h>
  52 #include <sys/mountctl.h>
  53 #include <sys/vfs_quota.h>
  54 #include <sys/uio.h>
  55
  56 #include <machine/limits.h>
  57
  58 #include <vm/vm.h>
  59 #include <vm/vm_object.h>
  60 #include <vm/vm_page.h>
  61 #include <vm/vm_pager.h>
  62 #include <vm/vnode_pager.h>
  63
  64 static int      vop_nolookup (struct vop_old_lookup_args *);
  65 static int      vop_nostrategy (struct vop_strategy_args *);
  66
  67 /*
  68  * This vnode table stores what we want to do if the filesystem doesn't
  69  * implement a particular VOP.
  70  *
  71  * If there is no specific entry here, we will return EOPNOTSUPP.
  72  */
  73 struct vop_ops default_vnode_vops = {
  74         .vop_default            = vop_eopnotsupp,
  75         .vop_advlock            = (void *)vop_einval,
  76         .vop_fsync              = (void *)vop_null,
  77         .vop_fdatasync          = vop_stdfdatasync,
  78         .vop_ioctl              = (void *)vop_enotty,
  79         .vop_mmap               = (void *)vop_einval,
  80         .vop_old_lookup         = vop_nolookup,
  81         .vop_open               = vop_stdopen,
  82         .vop_close              = vop_stdclose,
  83         .vop_getattr_lite       = vop_stdgetattr_lite,
  84         .vop_pathconf           = vop_stdpathconf,
  85         .vop_readlink           = (void *)vop_einval,
  86         .vop_reallocblks        = (void *)vop_eopnotsupp,
  87         .vop_strategy           = vop_nostrategy,
  88         .vop_getacl             = (void *)vop_eopnotsupp,
  89         .vop_setacl             = (void *)vop_eopnotsupp,
  90         .vop_aclcheck           = (void *)vop_eopnotsupp,
  91         .vop_getextattr         = (void *)vop_eopnotsupp,
  92         .vop_setextattr         = (void *)vop_eopnotsupp,
  93         .vop_markatime          = vop_stdmarkatime,
  94         .vop_allocate           = vop_stdallocate,
  95         .vop_nresolve           = vop_compat_nresolve,
  96         .vop_nlookupdotdot      = vop_compat_nlookupdotdot,
  97         .vop_ncreate            = vop_compat_ncreate,
  98         .vop_nmkdir             = vop_compat_nmkdir,
  99         .vop_nmknod             = vop_compat_nmknod,
 100         .vop_nlink              = vop_compat_nlink,
 101         .vop_nsymlink           = vop_compat_nsymlink,
 102         .vop_nwhiteout          = vop_compat_nwhiteout,
 103         .vop_nremove            = vop_compat_nremove,
 104         .vop_nrmdir             = vop_compat_nrmdir,
 105         .vop_nrename            = vop_compat_nrename,
 106         .vop_mountctl           = vop_stdmountctl
 107 };
 108
 109 VNODEOP_SET(default_vnode_vops);
 110
 111 int
 112 vop_eopnotsupp(struct vop_generic_args *ap)
 113 {
 114         return (EOPNOTSUPP);
 115 }
 116
 117 int
 118 vop_ebadf(struct vop_generic_args *ap)
 119 {
 120         return (EBADF);
 121 }
 122
 123 int
 124 vop_enotty(struct vop_generic_args *ap)
 125 {
 126         return (ENOTTY);
 127 }
 128
 129 int
 130 vop_einval(struct vop_generic_args *ap)
 131 {
 132         return (EINVAL);
 133 }
 134
 135 int
 136 vop_stdmarkatime(struct vop_markatime_args *ap)
 137 {
 138         return (EOPNOTSUPP);
 139 }
 140
 141 int
 142 vop_null(struct vop_generic_args *ap)
 143 {
 144         return (0);
 145 }
 146
 147 int
 148 vop_defaultop(struct vop_generic_args *ap)
 149 {
 150         return (VOCALL(&default_vnode_vops, ap));
 151 }
 152
 153 /*
 154  * vop_compat_resolve { struct nchandle *a_nch, struct vnode *dvp }
 155  * XXX STOPGAP FUNCTION
 156  *
 157  * XXX OLD API ROUTINE!  WHEN ALL VFSs HAVE BEEN CLEANED UP THIS PROCEDURE
 158  * WILL BE REMOVED.  This procedure exists for all VFSs which have not
 159  * yet implemented VOP_NRESOLVE().  It converts VOP_NRESOLVE() into a
 160  * vop_old_lookup() and does appropriate translations.
 161  *
 162  * Resolve a ncp for VFSs which do not support the VOP.  Eventually all
 163  * VFSs will support this VOP and this routine can be removed, since
 164  * VOP_NRESOLVE() is far less complex then the older LOOKUP/CACHEDLOOKUP
 165  * API.
 166  *
 167  * A locked ncp is passed in to be resolved.  The NCP is resolved by
 168  * figuring out the vnode (if any) and calling cache_setvp() to attach the
 169  * vnode to the entry.  If the entry represents a non-existant node then
 170  * cache_setvp() is called with a NULL vnode to resolve the entry into a
 171  * negative cache entry.  No vnode locks are retained and the
 172  * ncp is left locked on return.
 173  *
 174  * The ncp will NEVER represent "", "." or "..", or contain any slashes.
 175  *
 176  * There is a potential directory and vnode interlock.   The lock order
 177  * requirement is: namecache, governing directory, resolved vnode.
 178  */
 179 int
 180 vop_compat_nresolve(struct vop_nresolve_args *ap)
 181 {
 182         int error;
 183         struct vnode *dvp;
 184         struct vnode *vp;
 185         struct nchandle *nch;
 186         struct namecache *ncp;
 187         struct componentname cnp;
 188
 189         nch = ap->a_nch;        /* locked namecache node */
 190         ncp = nch->ncp;
 191         dvp = ap->a_dvp;
 192
 193         /*
 194          * UFS currently stores all sorts of side effects, including a loop
 195          * variable, in the directory inode.  That needs to be fixed and the
 196          * other VFS's audited before we can switch to LK_SHARED.
 197          */
 198         if ((error = vget(dvp, LK_EXCLUSIVE)) != 0) {
 199                 kprintf("[diagnostic] vop_compat_resolve: EAGAIN on ncp %p %s\n",
 200                         ncp, ncp->nc_name);
 201                 return(EAGAIN);
 202         }
 203
 204         bzero(&cnp, sizeof(cnp));
 205         cnp.cn_nameiop = NAMEI_LOOKUP;
 206         cnp.cn_flags = 0;
 207         cnp.cn_nameptr = ncp->nc_name;
 208         cnp.cn_namelen = ncp->nc_nlen;
 209         cnp.cn_cred = ap->a_cred;
 210         cnp.cn_td = curthread; /* XXX */
 211
 212         /*
 213          * vop_old_lookup() always returns vp locked.  dvp may or may not be
 214          * left locked depending on CNP_PDIRUNLOCK.
 215          */
 216         error = vop_old_lookup(ap->a_head.a_ops, dvp, &vp, &cnp);
 217         if (error == 0)
 218                 vn_unlock(vp);
 219         if ((cnp.cn_flags & CNP_PDIRUNLOCK) == 0)
 220                 vn_unlock(dvp);
 221         if ((ncp->nc_flag & NCF_UNRESOLVED) == 0) {
 222                 /* was resolved by another process while we were unlocked */
 223                 if (error == 0)
 224                         vrele(vp);
 225         } else if (error == 0) {
 226                 KKASSERT(vp != NULL);
 227                 cache_setvp(nch, vp);
 228                 vrele(vp);
 229         } else if (error == ENOENT) {
 230                 KKASSERT(vp == NULL);
 231                 if (cnp.cn_flags & CNP_ISWHITEOUT)
 232                         ncp->nc_flag |= NCF_WHITEOUT;
 233                 cache_setvp(nch, NULL);
 234         }
 235         vrele(dvp);
 236         return (error);
 237 }
 238
 239 /*
 240  * vop_compat_nlookupdotdot { struct vnode *a_dvp,
 241  *                      struct vnode **a_vpp,
 242  *                      struct ucred *a_cred }
 243  *
 244  * Lookup the vnode representing the parent directory of the specified
 245  * directory vnode.  a_dvp should not be locked.  If no error occurs *a_vpp
 246  * will contained the parent vnode, locked and refd, else *a_vpp will be NULL.
 247  *
 248  * This function is designed to aid NFS server-side operations and is
 249  * used by cache_fromdvp() to create a consistent, connected namecache
 250  * topology.
 251  *
 252  * As part of the NEW API work, VFSs will first split their CNP_ISDOTDOT
 253  * code out from their *_lookup() and create *_nlookupdotdot().  Then as time
 254  * permits VFSs will implement the remaining *_n*() calls and finally get
 255  * rid of their *_lookup() call.
 256  */
 257 int
 258 vop_compat_nlookupdotdot(struct vop_nlookupdotdot_args *ap)
 259 {
 260         struct componentname cnp;
 261         int error;
 262
 263         /*
 264          * UFS currently stores all sorts of side effects, including a loop
 265          * variable, in the directory inode.  That needs to be fixed and the
 266          * other VFS's audited before we can switch to LK_SHARED.
 267          */
 268         *ap->a_vpp = NULL;
 269         if ((error = vget(ap->a_dvp, LK_EXCLUSIVE)) != 0)
 270                 return (error);
 271         if (ap->a_dvp->v_type != VDIR) {
 272                 vput(ap->a_dvp);
 273                 return (ENOTDIR);
 274         }
 275
 276         bzero(&cnp, sizeof(cnp));
 277         cnp.cn_nameiop = NAMEI_LOOKUP;
 278         cnp.cn_flags = CNP_ISDOTDOT;
 279         cnp.cn_nameptr = "..";
 280         cnp.cn_namelen = 2;
 281         cnp.cn_cred = ap->a_cred;
 282         cnp.cn_td = curthread; /* XXX */
 283
 284         /*
 285          * vop_old_lookup() always returns vp locked.  dvp may or may not be
 286          * left locked depending on CNP_PDIRUNLOCK.
 287          *
 288          * (*vpp) will be returned locked if no error occured, which is the
 289          * state we want.
 290          */
 291         error = vop_old_lookup(ap->a_head.a_ops, ap->a_dvp, ap->a_vpp, &cnp);
 292         if (cnp.cn_flags & CNP_PDIRUNLOCK)
 293                 vrele(ap->a_dvp);
 294         else
 295                 vput(ap->a_dvp);
 296         return (error);
 297 }
 298
 299 /*
 300  * vop_compat_ncreate { struct nchandle *a_nch,         XXX STOPGAP FUNCTION
 301  *                      struct vnode *a_dvp,
 302  *                      struct vnode **a_vpp,
 303  *                      struct ucred *a_cred,
 304  *                      struct vattr *a_vap }
 305  *
 306  * Create a file as specified by a_vap.  Compatibility requires us to issue
 307  * the appropriate VOP_OLD_LOOKUP before we issue VOP_OLD_CREATE in order
 308  * to setup the directory inode's i_offset and i_count (e.g. in UFS).
 309  */
 310 int
 311 vop_compat_ncreate(struct vop_ncreate_args *ap)
 312 {
 313         struct thread *td = curthread;
 314         struct componentname cnp;
 315         struct nchandle *nch;
 316         struct namecache *ncp;
 317         struct vnode *dvp;
 318         int error;
 319
 320         /*
 321          * Sanity checks, get a locked directory vnode.
 322          */
 323         nch = ap->a_nch;                /* locked namecache node */
 324         dvp = ap->a_dvp;
 325         ncp = nch->ncp;
 326
 327         if ((error = vget(dvp, LK_EXCLUSIVE)) != 0) {
 328                 kprintf("[diagnostic] vop_compat_resolve: EAGAIN on ncp %p %s\n",
 329                         ncp, ncp->nc_name);
 330                 return(EAGAIN);
 331         }
 332
 333         /*
 334          * Setup the cnp for a traditional vop_old_lookup() call.  The lookup
 335          * caches all information required to create the entry in the
 336          * directory inode.  We expect a return code of EJUSTRETURN for
 337          * the CREATE case.  The cnp must simulated a saved-name situation.
 338          */
 339         bzero(&cnp, sizeof(cnp));
 340         cnp.cn_nameiop = NAMEI_CREATE;
 341         cnp.cn_flags = CNP_LOCKPARENT;
 342         cnp.cn_nameptr = ncp->nc_name;
 343         cnp.cn_namelen = ncp->nc_nlen;
 344         cnp.cn_cred = ap->a_cred;
 345         cnp.cn_td = td;
 346         *ap->a_vpp = NULL;
 347
 348         error = vop_old_lookup(ap->a_head.a_ops, dvp, ap->a_vpp, &cnp);
 349
 350         /*
 351          * EJUSTRETURN should be returned for this case, which means that
 352          * the VFS has setup the directory inode for the create.  The dvp we
 353          * passed in is expected to remain in a locked state.
 354          *
 355          * If the VOP_OLD_CREATE is successful we are responsible for updating
 356          * the cache state of the locked ncp that was passed to us.
 357          */
 358         if (error == EJUSTRETURN) {
 359                 KKASSERT((cnp.cn_flags & CNP_PDIRUNLOCK) == 0);
 360                 error = VOP_OLD_CREATE(dvp, ap->a_vpp, &cnp, ap->a_vap);
 361                 if (error == 0) {
 362                         cache_setunresolved(nch);
 363                         cache_setvp(nch, *ap->a_vpp);
 364                 }
 365         } else {
 366                 if (error == 0) {
 367                         vput(*ap->a_vpp);
 368                         *ap->a_vpp = NULL;
 369                         error = EEXIST;
 370                 }
 371                 KKASSERT(*ap->a_vpp == NULL);
 372         }
 373         if ((cnp.cn_flags & CNP_PDIRUNLOCK) == 0)
 374                 vn_unlock(dvp);
 375         vrele(dvp);
 376         return (error);
 377 }
 378
 379 /*
 380  * vop_compat_nmkdir { struct nchandle *a_nch,  XXX STOPGAP FUNCTION
 381  *                      struct vnode *a_dvp,
 382  *                      struct vnode **a_vpp,
 383  *                      struct ucred *a_cred,
 384  *                      struct vattr *a_vap }
 385  *
 386  * Create a directory as specified by a_vap.  Compatibility requires us to
 387  * issue the appropriate VOP_OLD_LOOKUP before we issue VOP_OLD_MKDIR in
 388  * order to setup the directory inode's i_offset and i_count (e.g. in UFS).
 389  */
 390 int
 391 vop_compat_nmkdir(struct vop_nmkdir_args *ap)
 392 {
 393         struct thread *td = curthread;
 394         struct componentname cnp;
 395         struct nchandle *nch;
 396         struct namecache *ncp;
 397         struct vnode *dvp;
 398         int error;
 399
 400         /*
 401          * Sanity checks, get a locked directory vnode.
 402          */
 403         nch = ap->a_nch;                /* locked namecache node */
 404         ncp = nch->ncp;
 405         dvp = ap->a_dvp;
 406         if ((error = vget(dvp, LK_EXCLUSIVE)) != 0) {
 407                 kprintf("[diagnostic] vop_compat_resolve: EAGAIN on ncp %p %s\n",
 408                         ncp, ncp->nc_name);
 409                 return(EAGAIN);
 410         }
 411
 412         /*
 413          * Setup the cnp for a traditional vop_old_lookup() call.  The lookup
 414          * caches all information required to create the entry in the
 415          * directory inode.  We expect a return code of EJUSTRETURN for
 416          * the CREATE case.  The cnp must simulated a saved-name situation.
 417          */
 418         bzero(&cnp, sizeof(cnp));
 419         cnp.cn_nameiop = NAMEI_CREATE;
 420         cnp.cn_flags = CNP_LOCKPARENT;
 421         cnp.cn_nameptr = ncp->nc_name;
 422         cnp.cn_namelen = ncp->nc_nlen;
 423         cnp.cn_cred = ap->a_cred;
 424         cnp.cn_td = td;
 425         *ap->a_vpp = NULL;
 426
 427         error = vop_old_lookup(ap->a_head.a_ops, dvp, ap->a_vpp, &cnp);
 428
 429         /*
 430          * EJUSTRETURN should be returned for this case, which means that
 431          * the VFS has setup the directory inode for the create.  The dvp we
 432          * passed in is expected to remain in a locked state.
 433          *
 434          * If the VOP_OLD_MKDIR is successful we are responsible for updating
 435          * the cache state of the locked ncp that was passed to us.
 436          */
 437         if (error == EJUSTRETURN) {
 438                 KKASSERT((cnp.cn_flags & CNP_PDIRUNLOCK) == 0);
 439                 error = VOP_OLD_MKDIR(dvp, ap->a_vpp, &cnp, ap->a_vap);
 440                 if (error == 0) {
 441                         cache_setunresolved(nch);
 442                         cache_setvp(nch, *ap->a_vpp);
 443                 }
 444         } else {
 445                 if (error == 0) {
 446                         vput(*ap->a_vpp);
 447                         *ap->a_vpp = NULL;
 448                         error = EEXIST;
 449                 }
 450                 KKASSERT(*ap->a_vpp == NULL);
 451         }
 452         if ((cnp.cn_flags & CNP_PDIRUNLOCK) == 0)
 453                 vn_unlock(dvp);
 454         vrele(dvp);
 455         return (error);
 456 }
 457
 458 /*
 459  * vop_compat_nmknod { struct nchandle *a_nch,  XXX STOPGAP FUNCTION
 460  *                      struct vnode *a_dvp,
 461  *                      struct vnode **a_vpp,
 462  *                      struct ucred *a_cred,
 463  *                      struct vattr *a_vap }
 464  *
 465  * Create a device or fifo node as specified by a_vap.  Compatibility requires
 466  * us to issue the appropriate VOP_OLD_LOOKUP before we issue VOP_OLD_MKNOD
 467  * in order to setup the directory inode's i_offset and i_count (e.g. in UFS).
 468  */
 469 int
 470 vop_compat_nmknod(struct vop_nmknod_args *ap)
 471 {
 472         struct thread *td = curthread;
 473         struct componentname cnp;
 474         struct nchandle *nch;
 475         struct namecache *ncp;
 476         struct vnode *dvp;
 477         int error;
 478
 479         /*
 480          * Sanity checks, get a locked directory vnode.
 481          */
 482         nch = ap->a_nch;                /* locked namecache node */
 483         ncp = nch->ncp;
 484         dvp = ap->a_dvp;
 485
 486         if ((error = vget(dvp, LK_EXCLUSIVE)) != 0) {
 487                 kprintf("[diagnostic] vop_compat_resolve: EAGAIN on ncp %p %s\n",
 488                         ncp, ncp->nc_name);
 489                 return(EAGAIN);
 490         }
 491
 492         /*
 493          * Setup the cnp for a traditional vop_old_lookup() call.  The lookup
 494          * caches all information required to create the entry in the
 495          * directory inode.  We expect a return code of EJUSTRETURN for
 496          * the CREATE case.  The cnp must simulated a saved-name situation.
 497          */
 498         bzero(&cnp, sizeof(cnp));
 499         cnp.cn_nameiop = NAMEI_CREATE;
 500         cnp.cn_flags = CNP_LOCKPARENT;
 501         cnp.cn_nameptr = ncp->nc_name;
 502         cnp.cn_namelen = ncp->nc_nlen;
 503         cnp.cn_cred = ap->a_cred;
 504         cnp.cn_td = td;
 505         *ap->a_vpp = NULL;
 506
 507         error = vop_old_lookup(ap->a_head.a_ops, dvp, ap->a_vpp, &cnp);
 508
 509         /*
 510          * EJUSTRETURN should be returned for this case, which means that
 511          * the VFS has setup the directory inode for the create.  The dvp we
 512          * passed in is expected to remain in a locked state.
 513          *
 514          * If the VOP_OLD_MKNOD is successful we are responsible for updating
 515          * the cache state of the locked ncp that was passed to us.
 516          */
 517         if (error == EJUSTRETURN) {
 518                 KKASSERT((cnp.cn_flags & CNP_PDIRUNLOCK) == 0);
 519                 error = VOP_OLD_MKNOD(dvp, ap->a_vpp, &cnp, ap->a_vap);
 520                 if (error == 0) {
 521                         cache_setunresolved(nch);
 522                         cache_setvp(nch, *ap->a_vpp);
 523                 }
 524         } else {
 525                 if (error == 0) {
 526                         vput(*ap->a_vpp);
 527                         *ap->a_vpp = NULL;
 528                         error = EEXIST;
 529                 }
 530                 KKASSERT(*ap->a_vpp == NULL);
 531         }
 532         if ((cnp.cn_flags & CNP_PDIRUNLOCK) == 0)
 533                 vn_unlock(dvp);
 534         vrele(dvp);
 535         return (error);
 536 }
 537
 538 /*
 539  * vop_compat_nlink { struct nchandle *a_nch,   XXX STOPGAP FUNCTION
 540  *                      struct vnode *a_dvp,
 541  *                      struct vnode *a_vp,
 542  *                      struct ucred *a_cred }
 543  *
 544  * The passed vp is locked and represents the source.  The passed ncp is
 545  * locked and represents the target to create.
 546  */
 547 int
 548 vop_compat_nlink(struct vop_nlink_args *ap)
 549 {
 550         struct thread *td = curthread;
 551         struct componentname cnp;
 552         struct nchandle *nch;
 553         struct namecache *ncp;
 554         struct vnode *dvp;
 555         struct vnode *tvp;
 556         int error;
 557
 558         /*
 559          * Sanity checks, get a locked directory vnode.
 560          */
 561         nch = ap->a_nch;                /* locked namecache node */
 562         ncp = nch->ncp;
 563         dvp = ap->a_dvp;
 564
 565         if ((error = vget(dvp, LK_EXCLUSIVE)) != 0) {
 566                 kprintf("[diagnostic] vop_compat_resolve: EAGAIN on ncp %p %s\n",
 567                         ncp, ncp->nc_name);
 568                 return(EAGAIN);
 569         }
 570
 571         /*
 572          * Setup the cnp for a traditional vop_old_lookup() call.  The lookup
 573          * caches all information required to create the entry in the
 574          * directory inode.  We expect a return code of EJUSTRETURN for
 575          * the CREATE case.  The cnp must simulated a saved-name situation.
 576          *
 577          * It should not be possible for there to be a vnode collision
 578          * between the source vp and target (name lookup).  However NFS
 579          * clients racing each other can cause NFS to alias the same vnode
 580          * across several names without the rest of the system knowing it.
 581          * Use CNP_NOTVP to avoid a panic in this situation.
 582          */
 583         bzero(&cnp, sizeof(cnp));
 584         cnp.cn_nameiop = NAMEI_CREATE;
 585         cnp.cn_flags = CNP_LOCKPARENT | CNP_NOTVP;
 586         cnp.cn_nameptr = ncp->nc_name;
 587         cnp.cn_namelen = ncp->nc_nlen;
 588         cnp.cn_cred = ap->a_cred;
 589         cnp.cn_td = td;
 590         cnp.cn_notvp = ap->a_vp;
 591
 592         tvp = NULL;
 593         error = vop_old_lookup(ap->a_head.a_ops, dvp, &tvp, &cnp);
 594
 595         /*
 596          * EJUSTRETURN should be returned for this case, which means that
 597          * the VFS has setup the directory inode for the create.  The dvp we
 598          * passed in is expected to remain in a locked state.
 599          *
 600          * If the VOP_OLD_LINK is successful we are responsible for updating
 601          * the cache state of the locked ncp that was passed to us.
 602          */
 603         if (error == EJUSTRETURN) {
 604                 KKASSERT((cnp.cn_flags & CNP_PDIRUNLOCK) == 0);
 605                 error = VOP_OLD_LINK(dvp, ap->a_vp, &cnp);
 606                 if (error == 0) {
 607                         cache_setunresolved(nch);
 608                         cache_setvp(nch, ap->a_vp);
 609                 }
 610         } else {
 611                 if (error == 0) {
 612                         vput(tvp);
 613                         error = EEXIST;
 614                 }
 615         }
 616         if ((cnp.cn_flags & CNP_PDIRUNLOCK) == 0)
 617                 vn_unlock(dvp);
 618         vrele(dvp);
 619         return (error);
 620 }
 621
 622 int
 623 vop_compat_nsymlink(struct vop_nsymlink_args *ap)
 624 {
 625         struct thread *td = curthread;
 626         struct componentname cnp;
 627         struct nchandle *nch;
 628         struct namecache *ncp;
 629         struct vnode *dvp;
 630         struct vnode *vp;
 631         int error;
 632
 633         /*
 634          * Sanity checks, get a locked directory vnode.
 635          */
 636         *ap->a_vpp = NULL;
 637         nch = ap->a_nch;                /* locked namecache node */
 638         ncp = nch->ncp;
 639         dvp = ap->a_dvp;
 640
 641         if ((error = vget(dvp, LK_EXCLUSIVE)) != 0) {
 642                 kprintf("[diagnostic] vop_compat_resolve: EAGAIN on ncp %p %s\n",
 643                         ncp, ncp->nc_name);
 644                 return(EAGAIN);
 645         }
 646
 647         /*
 648          * Setup the cnp for a traditional vop_old_lookup() call.  The lookup
 649          * caches all information required to create the entry in the
 650          * directory inode.  We expect a return code of EJUSTRETURN for
 651          * the CREATE case.  The cnp must simulated a saved-name situation.
 652          */
 653         bzero(&cnp, sizeof(cnp));
 654         cnp.cn_nameiop = NAMEI_CREATE;
 655         cnp.cn_flags = CNP_LOCKPARENT;
 656         cnp.cn_nameptr = ncp->nc_name;
 657         cnp.cn_namelen = ncp->nc_nlen;
 658         cnp.cn_cred = ap->a_cred;
 659         cnp.cn_td = td;
 660
 661         vp = NULL;
 662         error = vop_old_lookup(ap->a_head.a_ops, dvp, &vp, &cnp);
 663
 664         /*
 665          * EJUSTRETURN should be returned for this case, which means that
 666          * the VFS has setup the directory inode for the create.  The dvp we
 667          * passed in is expected to remain in a locked state.
 668          *
 669          * If the VOP_OLD_SYMLINK is successful we are responsible for updating
 670          * the cache state of the locked ncp that was passed to us.
 671          */
 672         if (error == EJUSTRETURN) {
 673                 KKASSERT((cnp.cn_flags & CNP_PDIRUNLOCK) == 0);
 674                 error = VOP_OLD_SYMLINK(dvp, &vp, &cnp, ap->a_vap, ap->a_target);
 675                 if (error == 0) {
 676                         cache_setunresolved(nch);
 677                         cache_setvp(nch, vp);
 678                         *ap->a_vpp = vp;
 679                 }
 680         } else {
 681                 if (error == 0) {
 682                         vput(vp);
 683                         vp = NULL;
 684                         error = EEXIST;
 685                 }
 686                 KKASSERT(vp == NULL);
 687         }
 688         if ((cnp.cn_flags & CNP_PDIRUNLOCK) == 0)
 689                 vn_unlock(dvp);
 690         vrele(dvp);
 691         return (error);
 692 }
 693
 694 /*
 695  * vop_compat_nwhiteout { struct nchandle *a_nch,       XXX STOPGAP FUNCTION
 696  *                        struct vnode *a_dvp,
 697  *                        struct ucred *a_cred,
 698  *                        int a_flags }
 699  *
 700  * Issie a whiteout operation (create, lookup, or delete).  Compatibility
 701  * requires us to issue the appropriate VOP_OLD_LOOKUP before we issue
 702  * VOP_OLD_WHITEOUT in order to setup the directory inode's i_offset and i_count
 703  * (e.g. in UFS) for the NAMEI_CREATE and NAMEI_DELETE ops.  For NAMEI_LOOKUP
 704  * no lookup is necessary.
 705  */
 706 int
 707 vop_compat_nwhiteout(struct vop_nwhiteout_args *ap)
 708 {
 709         struct thread *td = curthread;
 710         struct componentname cnp;
 711         struct nchandle *nch;
 712         struct namecache *ncp;
 713         struct vnode *dvp;
 714         struct vnode *vp;
 715         int error;
 716
 717         /*
 718          * Sanity checks, get a locked directory vnode.
 719          */
 720         nch = ap->a_nch;                /* locked namecache node */
 721         ncp = nch->ncp;
 722         dvp = ap->a_dvp;
 723
 724         if ((error = vget(dvp, LK_EXCLUSIVE)) != 0) {
 725                 kprintf("[diagnostic] vop_compat_resolve: EAGAIN on ncp %p %s\n",
 726                         ncp, ncp->nc_name);
 727                 return(EAGAIN);
 728         }
 729
 730         /*
 731          * Setup the cnp for a traditional vop_old_lookup() call.  The lookup
 732          * caches all information required to create the entry in the
 733          * directory inode.  We expect a return code of EJUSTRETURN for
 734          * the CREATE case.  The cnp must simulated a saved-name situation.
 735          */
 736         bzero(&cnp, sizeof(cnp));
 737         cnp.cn_nameiop = ap->a_flags;
 738         cnp.cn_flags = CNP_LOCKPARENT;
 739         cnp.cn_nameptr = ncp->nc_name;
 740         cnp.cn_namelen = ncp->nc_nlen;
 741         cnp.cn_cred = ap->a_cred;
 742         cnp.cn_td = td;
 743
 744         vp = NULL;
 745
 746         /*
 747          * EJUSTRETURN should be returned for the CREATE or DELETE cases.
 748          * The VFS has setup the directory inode for the create.  The dvp we
 749          * passed in is expected to remain in a locked state.
 750          *
 751          * If the VOP_OLD_WHITEOUT is successful we are responsible for updating
 752          * the cache state of the locked ncp that was passed to us.
 753          */
 754         switch(ap->a_flags) {
 755         case NAMEI_DELETE:
 756                 cnp.cn_flags |= CNP_DOWHITEOUT;
 757                 /* fall through */
 758         case NAMEI_CREATE:
 759                 error = vop_old_lookup(ap->a_head.a_ops, dvp, &vp, &cnp);
 760                 if (error == EJUSTRETURN) {
 761                         KKASSERT((cnp.cn_flags & CNP_PDIRUNLOCK) == 0);
 762                         error = VOP_OLD_WHITEOUT(dvp, &cnp, ap->a_flags);
 763                         if (error == 0)
 764                                 cache_setunresolved(nch);
 765                 } else {
 766                         if (error == 0) {
 767                                 vput(vp);
 768                                 vp = NULL;
 769                                 error = EEXIST;
 770                         }
 771                         KKASSERT(vp == NULL);
 772                 }
 773                 break;
 774         case NAMEI_LOOKUP:
 775                 error = VOP_OLD_WHITEOUT(dvp, NULL, ap->a_flags);
 776                 break;
 777         default:
 778                 error = EINVAL;
 779                 break;
 780         }
 781         if ((cnp.cn_flags & CNP_PDIRUNLOCK) == 0)
 782                 vn_unlock(dvp);
 783         vrele(dvp);
 784         return (error);
 785 }
 786
 787
 788 /*
 789  * vop_compat_nremove { struct nchandle *a_nch,         XXX STOPGAP FUNCTION
 790  *                      struct vnode *a_dvp,
 791  *                      struct ucred *a_cred }
 792  */
 793 int
 794 vop_compat_nremove(struct vop_nremove_args *ap)
 795 {
 796         struct thread *td = curthread;
 797         struct componentname cnp;
 798         struct nchandle *nch;
 799         struct namecache *ncp;
 800         struct vnode *dvp;
 801         struct vnode *vp;
 802         int error;
 803
 804         /*
 805          * Sanity checks, get a locked directory vnode.
 806          */
 807         nch = ap->a_nch;                /* locked namecache node */
 808         ncp = nch->ncp;
 809         dvp = ap->a_dvp;
 810
 811         if ((error = vget(dvp, LK_EXCLUSIVE)) != 0) {
 812                 kprintf("[diagnostic] vop_compat_resolve: EAGAIN on ncp %p %s\n",
 813                         ncp, ncp->nc_name);
 814                 return(EAGAIN);
 815         }
 816
 817         /*
 818          * Setup the cnp for a traditional vop_old_lookup() call.  The lookup
 819          * caches all information required to delete the entry in the
 820          * directory inode.  We expect a return code of 0 for the DELETE
 821          * case (meaning that a vp has been found).  The cnp must simulated
 822          * a saved-name situation.
 823          */
 824         bzero(&cnp, sizeof(cnp));
 825         cnp.cn_nameiop = NAMEI_DELETE;
 826         cnp.cn_flags = CNP_LOCKPARENT;
 827         cnp.cn_nameptr = ncp->nc_name;
 828         cnp.cn_namelen = ncp->nc_nlen;
 829         cnp.cn_cred = ap->a_cred;
 830         cnp.cn_td = td;
 831
 832         /*
 833          * The vnode must be a directory and must not represent the
 834          * current directory.
 835          */
 836         vp = NULL;
 837         error = vop_old_lookup(ap->a_head.a_ops, dvp, &vp, &cnp);
 838         if (error == 0 && vp->v_type == VDIR)
 839                 error = EPERM;
 840         if (error == 0) {
 841                 KKASSERT((cnp.cn_flags & CNP_PDIRUNLOCK) == 0);
 842                 error = VOP_OLD_REMOVE(dvp, vp, &cnp);
 843                 if (error == 0)
 844                         cache_unlink(nch);
 845         }
 846         if (vp) {
 847                 if (dvp == vp)
 848                         vrele(vp);
 849                 else
 850                         vput(vp);
 851         }
 852         if ((cnp.cn_flags & CNP_PDIRUNLOCK) == 0)
 853                 vn_unlock(dvp);
 854         vrele(dvp);
 855         return (error);
 856 }
 857
 858 /*
 859  * vop_compat_nrmdir { struct nchandle *a_nch,  XXX STOPGAP FUNCTION
 860  *                     struct vnode *dvp,
 861  *                     struct ucred *a_cred }
 862  */
 863 int
 864 vop_compat_nrmdir(struct vop_nrmdir_args *ap)
 865 {
 866         struct thread *td = curthread;
 867         struct componentname cnp;
 868         struct nchandle *nch;
 869         struct namecache *ncp;
 870         struct vnode *dvp;
 871         struct vnode *vp;
 872         int error;
 873
 874         /*
 875          * Sanity checks, get a locked directory vnode.
 876          */
 877         nch = ap->a_nch;                /* locked namecache node */
 878         ncp = nch->ncp;
 879         dvp = ap->a_dvp;
 880
 881         if ((error = vget(dvp, LK_EXCLUSIVE)) != 0) {
 882                 kprintf("[diagnostic] vop_compat_resolve: EAGAIN on ncp %p %s\n",
 883                         ncp, ncp->nc_name);
 884                 return(EAGAIN);
 885         }
 886
 887         /*
 888          * Setup the cnp for a traditional vop_old_lookup() call.  The lookup
 889          * caches all information required to delete the entry in the
 890          * directory inode.  We expect a return code of 0 for the DELETE
 891          * case (meaning that a vp has been found).  The cnp must simulated
 892          * a saved-name situation.
 893          */
 894         bzero(&cnp, sizeof(cnp));
 895         cnp.cn_nameiop = NAMEI_DELETE;
 896         cnp.cn_flags = CNP_LOCKPARENT;
 897         cnp.cn_nameptr = ncp->nc_name;
 898         cnp.cn_namelen = ncp->nc_nlen;
 899         cnp.cn_cred = ap->a_cred;
 900         cnp.cn_td = td;
 901
 902         /*
 903          * The vnode must be a directory and must not represent the
 904          * current directory.
 905          */
 906         vp = NULL;
 907         error = vop_old_lookup(ap->a_head.a_ops, dvp, &vp, &cnp);
 908         if (error == 0 && vp->v_type != VDIR)
 909                 error = ENOTDIR;
 910         if (error == 0 && vp == dvp)
 911                 error = EINVAL;
 912         if (error == 0 && (vp->v_flag & VROOT))
 913                 error = EBUSY;
 914         if (error == 0) {
 915                 KKASSERT((cnp.cn_flags & CNP_PDIRUNLOCK) == 0);
 916                 error = VOP_OLD_RMDIR(dvp, vp, &cnp);
 917
 918                 /*
 919                  * Note that this invalidation will cause any process
 920                  * currently CD'd into the directory being removed to be
 921                  * disconnected from the topology and not be able to ".."
 922                  * back out.
 923                  */
 924                 if (error == 0) {
 925                         cache_inval(nch, CINV_DESTROY);
 926                         cache_inval_vp(vp, CINV_DESTROY);
 927                 }
 928         }
 929         if (vp) {
 930                 if (dvp == vp)
 931                         vrele(vp);
 932                 else
 933                         vput(vp);
 934         }
 935         if ((cnp.cn_flags & CNP_PDIRUNLOCK) == 0)
 936                 vn_unlock(dvp);
 937         vrele(dvp);
 938         return (error);
 939 }
 940
 941 /*
 942  * vop_compat_nrename { struct nchandle *a_fnch,        XXX STOPGAP FUNCTION
 943  *                      struct nchandle *a_tnch,
 944  *                      struct ucred *a_cred }
 945  *
 946  * This is a fairly difficult procedure.  The old VOP_OLD_RENAME requires that
 947  * the source directory and vnode be unlocked and the target directory and
 948  * vnode (if it exists) be locked.  All arguments will be vrele'd and
 949  * the targets will also be unlocked regardless of the return code.
 950  */
 951 int
 952 vop_compat_nrename(struct vop_nrename_args *ap)
 953 {
 954         struct thread *td = curthread;
 955         struct componentname fcnp;
 956         struct componentname tcnp;
 957         struct nchandle *fnch;
 958         struct nchandle *tnch;
 959         struct namecache *fncp;
 960         struct namecache *tncp;
 961         struct vnode *fdvp, *fvp;
 962         struct vnode *tdvp, *tvp;
 963         int error;
 964
 965         /*
 966          * Sanity checks, get referenced vnodes representing the source.
 967          */
 968         fnch = ap->a_fnch;              /* locked namecache node */
 969         fncp = fnch->ncp;
 970         fdvp = ap->a_fdvp;
 971
 972         /*
 973          * Temporarily lock the source directory and lookup in DELETE mode to
 974          * check permissions.  XXX delete permissions should have been
 975          * checked by nlookup(), we need to add NLC_DELETE for delete
 976          * checking.  It is unclear whether VFS's require the directory setup
 977          * info NAMEI_DELETE causes to be stored in the fdvp's inode, but
 978          * since it isn't locked and since UFS always does a relookup of
 979          * the source, it is believed that the only side effect that matters
 980          * is the permissions check.
 981          */
 982         if ((error = vget(fdvp, LK_EXCLUSIVE)) != 0) {
 983                 kprintf("[diagnostic] vop_compat_resolve: EAGAIN on ncp %p %s\n",
 984                         fncp, fncp->nc_name);
 985                 return(EAGAIN);
 986         }
 987
 988         bzero(&fcnp, sizeof(fcnp));
 989         fcnp.cn_nameiop = NAMEI_DELETE;
 990         fcnp.cn_flags = CNP_LOCKPARENT;
 991         fcnp.cn_nameptr = fncp->nc_name;
 992         fcnp.cn_namelen = fncp->nc_nlen;
 993         fcnp.cn_cred = ap->a_cred;
 994         fcnp.cn_td = td;
 995
 996         /*
 997          * note: vop_old_lookup (i.e. VOP_OLD_LOOKUP) always returns a locked
 998          * fvp.
 999          */
1000         fvp = NULL;
1001         error = vop_old_lookup(ap->a_head.a_ops, fdvp, &fvp, &fcnp);
1002         if (error == 0 && (fvp->v_flag & VROOT)) {
1003                 vput(fvp);      /* as if vop_old_lookup had failed */
1004                 error = EBUSY;
1005         }
1006         if ((fcnp.cn_flags & CNP_PDIRUNLOCK) == 0) {
1007                 fcnp.cn_flags |= CNP_PDIRUNLOCK;
1008                 vn_unlock(fdvp);
1009         }
1010         if (error) {
1011                 vrele(fdvp);
1012                 return (error);
1013         }
1014         vn_unlock(fvp);
1015
1016         /*
1017          * fdvp and fvp are now referenced and unlocked.
1018          *
1019          * Get a locked directory vnode for the target and lookup the target
1020          * in CREATE mode so it places the required information in the
1021          * directory inode.
1022          */
1023         tnch = ap->a_tnch;              /* locked namecache node */
1024         tncp = tnch->ncp;
1025         tdvp = ap->a_tdvp;
1026         if (error) {
1027                 vrele(fdvp);
1028                 vrele(fvp);
1029                 return (error);
1030         }
1031         if ((error = vget(tdvp, LK_EXCLUSIVE)) != 0) {
1032                 kprintf("[diagnostic] vop_compat_resolve: EAGAIN on ncp %p %s\n",
1033                         tncp, tncp->nc_name);
1034                 vrele(fdvp);
1035                 vrele(fvp);
1036                 return(EAGAIN);
1037         }
1038
1039         /*
1040          * Setup the cnp for a traditional vop_old_lookup() call.  The lookup
1041          * caches all information required to create the entry in the
1042          * target directory inode.
1043          */
1044         bzero(&tcnp, sizeof(tcnp));
1045         tcnp.cn_nameiop = NAMEI_RENAME;
1046         tcnp.cn_flags = CNP_LOCKPARENT;
1047         tcnp.cn_nameptr = tncp->nc_name;
1048         tcnp.cn_namelen = tncp->nc_nlen;
1049         tcnp.cn_cred = ap->a_cred;
1050         tcnp.cn_td = td;
1051
1052         tvp = NULL;
1053         error = vop_old_lookup(ap->a_head.a_ops, tdvp, &tvp, &tcnp);
1054
1055         if (error == EJUSTRETURN) {
1056                 /*
1057                  * Target does not exist.  tvp should be NULL.
1058                  */
1059                 KKASSERT(tvp == NULL);
1060                 KKASSERT((tcnp.cn_flags & CNP_PDIRUNLOCK) == 0);
1061                 error = VOP_OLD_RENAME(fdvp, fvp, &fcnp, tdvp, tvp, &tcnp);
1062                 if (error == 0)
1063                         cache_rename(fnch, tnch);
1064         } else if (error == 0) {
1065                 /*
1066                  * Target exists.  VOP_OLD_RENAME should correctly delete the
1067                  * target.
1068                  */
1069                 KKASSERT((tcnp.cn_flags & CNP_PDIRUNLOCK) == 0);
1070                 error = VOP_OLD_RENAME(fdvp, fvp, &fcnp, tdvp, tvp, &tcnp);
1071                 if (error == 0)
1072                         cache_rename(fnch, tnch);
1073         } else {
1074                 vrele(fdvp);
1075                 vrele(fvp);
1076                 if (tcnp.cn_flags & CNP_PDIRUNLOCK)
1077                         vrele(tdvp);
1078                 else
1079                         vput(tdvp);
1080         }
1081         return (error);
1082 }
1083
1084 static int
1085 vop_nolookup(struct vop_old_lookup_args *ap)
1086 {
1087
1088         *ap->a_vpp = NULL;
1089         return (ENOTDIR);
1090 }
1091
1092 /*
1093  *      vop_nostrategy:
1094  *
1095  *      Strategy routine for VFS devices that have none.
1096  *
1097  *      B_ERROR and B_INVAL must be cleared prior to calling any strategy
1098  *      routine.  Typically this is done for a BUF_CMD_READ strategy call.
1099  *      Typically B_INVAL is assumed to already be clear prior to a write
1100  *      and should not be cleared manually unless you just made the buffer
1101  *      invalid.  B_ERROR should be cleared either way.
1102  */
1103
1104 static int
1105 vop_nostrategy (struct vop_strategy_args *ap)
1106 {
1107         kprintf("No strategy for buffer at %p\n", ap->a_bio->bio_buf);
1108         vprint("", ap->a_vp);
1109         ap->a_bio->bio_buf->b_flags |= B_ERROR;
1110         ap->a_bio->bio_buf->b_error = EOPNOTSUPP;
1111         biodone(ap->a_bio);
1112         return (EOPNOTSUPP);
1113 }
1114
1115 int
1116 vop_stdpathconf(struct vop_pathconf_args *ap)
1117 {
1118         int error = 0;
1119
1120         switch (ap->a_name) {
1121         case _PC_CHOWN_RESTRICTED:
1122                 *ap->a_retval = _POSIX_CHOWN_RESTRICTED;
1123                 break;
1124         case _PC_LINK_MAX:
1125                 *ap->a_retval = LINK_MAX;
1126                 break;
1127         case _PC_MAX_CANON:
1128                 *ap->a_retval = MAX_CANON;
1129                 break;
1130         case _PC_MAX_INPUT:
1131                 *ap->a_retval = MAX_INPUT;
1132                 break;
1133         case _PC_NAME_MAX:
1134                 *ap->a_retval = NAME_MAX;
1135                 break;
1136         case _PC_NO_TRUNC:
1137                 *ap->a_retval = _POSIX_NO_TRUNC;
1138                 break;
1139         case _PC_PATH_MAX:
1140                 *ap->a_retval = PATH_MAX;
1141                 break;
1142         case _PC_PIPE_BUF:
1143                 *ap->a_retval = PIPE_BUF;
1144                 break;
1145         case _PC_VDISABLE:
1146                 *ap->a_retval = _POSIX_VDISABLE;
1147                 break;
1148         default:
1149                 error = EINVAL;
1150                 break;
1151         }
1152         return (error);
1153 }
1154
1155 /*
1156  * Standard open.
1157  *
1158  * (struct vnode *a_vp, int a_mode, struct ucred *a_ucred, struct file *a_fp)
1159  *
1160  * a_mode: note, 'F' modes, e.g. FREAD, FWRITE
1161  */
1162 int
1163 vop_stdopen(struct vop_open_args *ap)
1164 {
1165         struct vnode *vp = ap->a_vp;
1166         struct file *fp;
1167
1168         if (ap->a_fpp) {
1169                 fp = *ap->a_fpp;
1170
1171                 switch(vp->v_type) {
1172                 case VFIFO:
1173                         fp->f_type = DTYPE_FIFO;
1174                         break;
1175                 default:
1176                         fp->f_type = DTYPE_VNODE;
1177                         break;
1178                 }
1179                 /* retain flags not to be copied */
1180                 fp->f_flag = (fp->f_flag & ~FMASK) | (ap->a_mode & FMASK);
1181                 fp->f_ops = &vnode_fileops;
1182                 fp->f_data = vp;
1183                 vref(vp);
1184         }
1185         if (ap->a_mode & FWRITE)
1186                 atomic_add_int(&vp->v_writecount, 1);
1187         KKASSERT(vp->v_opencount >= 0 && vp->v_opencount != INT_MAX);
1188         atomic_add_int(&vp->v_opencount, 1);
1189         return (0);
1190 }
1191
1192 /*
1193  * Standard close.
1194  *
1195  * (struct vnode *a_vp, int a_fflag)
1196  *
1197  * a_fflag: note, 'F' modes, e.g. FREAD, FWRITE.  same as a_mode in stdopen?
1198  *
1199  * v_lastwrite_ts is used to record the timestamp that should be used to
1200  * set the file mtime for any asynchronously flushed pages modified via
1201  * mmap(), which can occur after the last close().
1202  */
1203 int
1204 vop_stdclose(struct vop_close_args *ap)
1205 {
1206         struct vnode *vp = ap->a_vp;
1207
1208         KASSERT(vp->v_opencount > 0,
1209                 ("VOP_STDCLOSE: BAD OPENCOUNT %p %d type=%d ops=%p flgs=%08x",
1210                 vp, vp->v_opencount, vp->v_type, *vp->v_ops, vp->v_flag));
1211         if (ap->a_fflag & FWRITE) {
1212                 KASSERT(vp->v_writecount > 0,
1213                         ("VOP_STDCLOSE: BAD WRITECOUNT %p %d",
1214                         vp, vp->v_writecount));
1215                 atomic_add_int(&vp->v_writecount, -1);
1216         }
1217         atomic_add_int(&vp->v_opencount, -1);
1218         return (0);
1219 }
1220
1221 /*
1222  * Standard getattr_lite
1223  *
1224  * Just calls getattr
1225  */
1226 int
1227 vop_stdgetattr_lite(struct vop_getattr_lite_args *ap)
1228 {
1229         struct vattr va;
1230         struct vattr_lite *lvap;
1231         int error;
1232
1233         error = VOP_GETATTR(ap->a_vp, &va);
1234         if (__predict_true(error == 0)) {
1235                 lvap = ap->a_lvap;
1236                 lvap->va_type = va.va_type;
1237                 lvap->va_nlink = va.va_nlink;
1238                 lvap->va_mode = va.va_mode;
1239                 lvap->va_uid = va.va_uid;
1240                 lvap->va_gid = va.va_gid;
1241                 lvap->va_size = va.va_size;
1242                 lvap->va_flags = va.va_flags;
1243         }
1244         return error;
1245 }
1246
1247 /*
1248  * Implement standard getpages and putpages.  All filesystems must use
1249  * the buffer cache to back regular files.
1250  */
1251 int
1252 vop_stdgetpages(struct vop_getpages_args *ap)
1253 {
1254         struct mount *mp;
1255         int error;
1256
1257         if ((mp = ap->a_vp->v_mount) != NULL) {
1258                 error = vnode_pager_generic_getpages(
1259                                 ap->a_vp, ap->a_m, ap->a_count,
1260                                 ap->a_reqpage, ap->a_seqaccess);
1261         } else {
1262                 error = VM_PAGER_BAD;
1263         }
1264         return (error);
1265 }
1266
1267 int
1268 vop_stdputpages(struct vop_putpages_args *ap)
1269 {
1270         struct mount *mp;
1271         int error;
1272
1273         if ((mp = ap->a_vp->v_mount) != NULL) {
1274                 error = vnode_pager_generic_putpages(
1275                                 ap->a_vp, ap->a_m, ap->a_count,
1276                                 ap->a_flags, ap->a_rtvals);
1277         } else {
1278                 error = VM_PAGER_BAD;
1279         }
1280         return (error);
1281 }
1282
1283 int
1284 vop_stdnoread(struct vop_read_args *ap)
1285 {
1286         return (EINVAL);
1287 }
1288
1289 int
1290 vop_stdnowrite(struct vop_write_args *ap)
1291 {
1292         return (EINVAL);
1293 }
1294
1295 /*
1296  * vfs default ops
1297  * used to fill the vfs fucntion table to get reasonable default return values.
1298  */
1299 int
1300 vop_stdmountctl(struct vop_mountctl_args *ap)
1301 {
1302
1303         struct mount *mp;
1304         int error = 0;
1305
1306         mp = ap->a_head.a_ops->head.vv_mount;
1307
1308         switch(ap->a_op) {
1309         case MOUNTCTL_MOUNTFLAGS:
1310                 /*
1311                  * Get a string buffer with all the mount flags
1312                  * names comman separated.
1313                  * mount(2) will use this information.
1314                  */
1315                 *ap->a_res = vfs_flagstostr(mp->mnt_flag & MNT_VISFLAGMASK, NULL,
1316                                             ap->a_buf, ap->a_buflen, &error);
1317                 break;
1318         case MOUNTCTL_INSTALL_VFS_JOURNAL:
1319         case MOUNTCTL_RESTART_VFS_JOURNAL:
1320         case MOUNTCTL_REMOVE_VFS_JOURNAL:
1321         case MOUNTCTL_RESYNC_VFS_JOURNAL:
1322         case MOUNTCTL_STATUS_VFS_JOURNAL:
1323                 error = journal_mountctl(ap);
1324                 break;
1325         default:
1326                 error = EOPNOTSUPP;
1327                 break;
1328         }
1329         return (error);
1330 }
1331
1332 int
1333 vop_stdallocate(struct vop_allocate_args *ap)
1334 {
1335         struct thread *td;
1336         struct vnode *vp;
1337         struct vattr vattr, *vap;
1338         struct uio auio;
1339         struct iovec aiov;
1340         uint8_t *buf;
1341         off_t offset, len, fsize;
1342         size_t iosize;
1343         int error;
1344
1345         bzero(&auio, sizeof(auio));
1346
1347         td = curthread;
1348         vap = &vattr;
1349         buf = NULL;
1350
1351         vp = ap->a_vp;
1352         offset = ap->a_offset;
1353         len = ap->a_len;
1354
1355         error = VOP_GETATTR(vp, vap);
1356         if (error != 0)
1357                 goto out;
1358         fsize = vap->va_size;
1359         iosize = vap->va_blocksize;
1360         if (iosize == 0)
1361                 iosize = BLKDEV_IOSIZE;
1362         if (iosize > vmaxiosize(vp))
1363                 iosize = vmaxiosize(vp);
1364         buf = kmalloc(iosize, M_TEMP, M_WAITOK);
1365
1366         if (offset + len > vap->va_size) {
1367                 /*
1368                  * Test offset + len against the filesystem's maxfilesize.
1369                  */
1370                 VATTR_NULL(&vattr);
1371                 vap->va_size = offset + len;
1372                 error = VOP_SETATTR(vp, vap, td->td_ucred);
1373                 if (error != 0)
1374                         goto out;
1375                 VATTR_NULL(&vattr);
1376                 vap->va_size = fsize;
1377                 error = VOP_SETATTR(vp, vap, td->td_ucred);
1378                 if (error != 0)
1379                         goto out;
1380         }
1381
1382         for (;;) {
1383                 /*
1384                  * Read and write back anything below the nominal file
1385                  * size.  There's currently no way outside the filesystem
1386                  * to know whether this area is sparse or not.
1387                  */
1388                 off_t cur = iosize;
1389                 if ((offset % iosize) != 0)
1390                         cur -= (offset % iosize);
1391                 if (cur > len)
1392                         cur = len;
1393                 if (offset < fsize) {
1394                         aiov.iov_base = buf;
1395                         aiov.iov_len = cur;
1396                         auio.uio_iov = &aiov;
1397                         auio.uio_iovcnt = 1;
1398                         auio.uio_offset = offset;
1399                         auio.uio_resid = cur;
1400                         auio.uio_segflg = UIO_SYSSPACE;
1401                         auio.uio_rw = UIO_READ;
1402                         auio.uio_td = td;
1403                         error = VOP_READ(vp, &auio, 0, td->td_ucred);
1404                         if (error != 0)
1405                                 break;
1406                         if (auio.uio_resid > 0) {
1407                                 bzero(buf + cur - auio.uio_resid,
1408                                     auio.uio_resid);
1409                         }
1410                 } else {
1411                         bzero(buf, cur);
1412                 }
1413
1414                 aiov.iov_base = buf;
1415                 aiov.iov_len = cur;
1416                 auio.uio_iov = &aiov;
1417                 auio.uio_iovcnt = 1;
1418                 auio.uio_offset = offset;
1419                 auio.uio_resid = cur;
1420                 auio.uio_segflg = UIO_SYSSPACE;
1421                 auio.uio_rw = UIO_WRITE;
1422                 auio.uio_td = td;
1423
1424                 error = VOP_WRITE(vp, &auio, 0, td->td_ucred);
1425                 if (error != 0)
1426                         break;
1427
1428                 len -= cur;
1429                 offset += cur;
1430                 if (len == 0)
1431                         break;
1432                 /*
1433                 if (should_yield())
1434                         break;
1435                 */
1436         }
1437 out:
1438         ap->a_offset = offset;
1439         ap->a_len = len;
1440         kfree(buf, M_TEMP);
1441
1442         return (error);
1443 }
1444
1445 int
1446 vop_stdfdatasync(struct vop_fdatasync_args *ap)
1447 {
1448         return (VOP_FSYNC_FP(ap->a_vp, ap->a_waitfor, ap->a_flags, ap->a_fp));
1449 }
1450
1451 int
1452 vfs_stdroot(struct mount *mp, struct vnode **vpp)
1453 {
1454         return (EOPNOTSUPP);
1455 }
1456
1457 int
1458 vfs_stdstatfs(struct mount *mp, struct statfs *sbp, struct ucred *cred)
1459 {
1460         return (EOPNOTSUPP);
1461 }
1462
1463 /*
1464  * If the VFS does not implement statvfs, then call statfs and convert
1465  * the values.  This code was taken from libc's __cvtstatvfs() function,
1466  * contributed by Joerg Sonnenberger.
1467  */
1468 int
1469 vfs_stdstatvfs(struct mount *mp, struct statvfs *sbp, struct ucred *cred)
1470 {
1471         struct statfs *in;
1472         int error;
1473
1474         in = &mp->mnt_stat;
1475         error = VFS_STATFS(mp, in, cred);
1476         if (error == 0) {
1477                 bzero(sbp, sizeof(*sbp));
1478
1479                 sbp->f_bsize = in->f_bsize;
1480                 sbp->f_frsize = in->f_bsize;
1481                 sbp->f_blocks = in->f_blocks;
1482                 sbp->f_bfree = in->f_bfree;
1483                 sbp->f_bavail = in->f_bavail;
1484                 sbp->f_files = in->f_files;
1485                 sbp->f_ffree = in->f_ffree;
1486
1487                 /*
1488                  * XXX
1489                  * This field counts the number of available inodes to non-root
1490                  * users, but this information is not available via statfs.
1491                  * Just ignore this issue by returning the total number
1492                  * instead.
1493                  */
1494                 sbp->f_favail = in->f_ffree;
1495
1496                 /*
1497                  * XXX
1498                  * This field has a different meaning for statfs and statvfs.
1499                  * For the former it is the cookie exported for NFS and not
1500                  * intended for normal userland use.
1501                  */
1502                 sbp->f_fsid = 0;
1503
1504                 sbp->f_flag = 0;
1505                 if (in->f_flags & MNT_RDONLY)
1506                         sbp->f_flag |= ST_RDONLY;
1507                 if (in->f_flags & MNT_NOSUID)
1508                         sbp->f_flag |= ST_NOSUID;
1509                 sbp->f_namemax = 0;
1510                 sbp->f_owner = in->f_owner;
1511                 /*
1512                  * XXX
1513                  * statfs contains the type as string, statvfs expects it as
1514                  * enumeration.
1515                  */
1516                 sbp->f_type = 0;
1517
1518                 sbp->f_syncreads = in->f_syncreads;
1519                 sbp->f_syncwrites = in->f_syncwrites;
1520                 sbp->f_asyncreads = in->f_asyncreads;
1521                 sbp->f_asyncwrites = in->f_asyncwrites;
1522         }
1523         return (error);
1524 }
1525
1526 int
1527 vfs_stdvptofh(struct vnode *vp, struct fid *fhp)
1528 {
1529         return (EOPNOTSUPP);
1530 }
1531
1532 int
1533 vfs_stdstart(struct mount *mp, int flags)
1534 {
1535         return (0);
1536 }
1537
1538 int
1539 vfs_stdquotactl(struct mount *mp, int cmds, uid_t uid,
1540         caddr_t arg, struct ucred *cred)
1541 {
1542         return (EOPNOTSUPP);
1543 }
1544
1545 int
1546 vfs_stdsync(struct mount *mp, int waitfor)
1547 {
1548         return (0);
1549 }
1550
1551 int
1552 vfs_stdnosync(struct mount *mp, int waitfor)
1553 {
1554         return (EOPNOTSUPP);
1555 }
1556
1557 int
1558 vfs_stdvget(struct mount *mp, struct vnode *dvp, ino_t ino, struct vnode **vpp)
1559 {
1560         return (EOPNOTSUPP);
1561 }
1562
1563 int
1564 vfs_stdfhtovp(struct mount *mp, struct vnode *rootvp,
1565               struct fid *fhp, struct vnode **vpp)
1566 {
1567         return (EOPNOTSUPP);
1568 }
1569
1570 int
1571 vfs_stdcheckexp(struct mount *mp, struct sockaddr *nam, int *extflagsp,
1572         struct ucred **credanonp)
1573 {
1574         return (EOPNOTSUPP);
1575 }
1576
1577 int
1578 vfs_stdinit(struct vfsconf *vfsp)
1579 {
1580         return (0);
1581 }
1582
1583 int
1584 vfs_stduninit(struct vfsconf *vfsp)
1585 {
1586         return(0);
1587 }
1588
1589 int
1590 vfs_stdextattrctl(struct mount *mp, int cmd, struct vnode *vp,
1591                  int attrnamespace, const char *attrname,
1592                  struct ucred *cred)
1593 {
1594         return(EOPNOTSUPP);
1595 }
1596
1597 #define ACCOUNTING_NB_FSTYPES 7
1598
1599 static const char *accounting_fstypes[ACCOUNTING_NB_FSTYPES] = {
1600         "ext2fs", "hammer", "mfs", "ntfs", "null", "tmpfs", "ufs" };
1601
1602 int
1603 vfs_stdac_init(struct mount *mp)
1604 {
1605         const char* fs_type;
1606         int i, fstype_ok = 0;
1607
1608         /* is mounted fs type one we want to do some accounting for ? */
1609         for (i=0; i<ACCOUNTING_NB_FSTYPES; i++) {
1610                 fs_type = accounting_fstypes[i];
1611                 if (strncmp(mp->mnt_stat.f_fstypename, fs_type,
1612                                         sizeof(mp->mnt_stat)) == 0) {
1613                         fstype_ok = 1;
1614                         break;
1615                 }
1616         }
1617         if (fstype_ok == 0)
1618                 return (0);
1619
1620         vq_init(mp);
1621         return (0);
1622 }
1623
1624 void
1625 vfs_stdac_done(struct mount *mp)
1626 {
1627         vq_done(mp);
1628 }
1629
1630 void
1631 vfs_stdncpgen_set(struct mount *mp, struct namecache *ncp)
1632 {
1633 }
1634
1635 int
1636 vfs_stdncpgen_test(struct mount *mp, struct namecache *ncp)
1637 {
1638         return 0;
1639 }
1640
1641 int
1642 vfs_stdmodifying(struct mount *mp)
1643 {
1644         if (mp->mnt_flag & MNT_RDONLY)
1645                 return EROFS;
1646         return 0;
1647 }
1648 /* end of vfs default ops */