The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/kern/vfs_default.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

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

Cache object: 3bbc26ee9e4c92ae0ecf38b1df24a1fa


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.