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/vnode_if.c

Version: -  FREEBSD  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

    1 /*      $NetBSD: vnode_if.c,v 1.47 2004/01/25 18:06:48 hannken Exp $    */
    2 
    3 /*
    4  * Warning: This file is generated automatically.
    5  * (Modifications made here may easily be lost!)
    6  *
    7  * Created from the file:
    8  *      NetBSD: vnode_if.src,v 1.38 2004/01/25 18:02:04 hannken Exp 
    9  * by the script:
   10  *      NetBSD: vnode_if.sh,v 1.34 2004/01/25 18:02:04 hannken Exp 
   11  */
   12 
   13 /*
   14  * Copyright (c) 1992, 1993, 1994, 1995
   15  *      The Regents of the University of California.  All rights reserved.
   16  *
   17  * Redistribution and use in source and binary forms, with or without
   18  * modification, are permitted provided that the following conditions
   19  * are met:
   20  * 1. Redistributions of source code must retain the above copyright
   21  *    notice, this list of conditions and the following disclaimer.
   22  * 2. Redistributions in binary form must reproduce the above copyright
   23  *    notice, this list of conditions and the following disclaimer in the
   24  *    documentation and/or other materials provided with the distribution.
   25  * 3. Neither the name of the University nor the names of its contributors
   26  *    may be used to endorse or promote products derived from this software
   27  *    without specific prior written permission.
   28  *
   29  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   30  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   31  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   32  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   33  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   34  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   35  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   36  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   37  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   38  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   39  * SUCH DAMAGE.
   40  */
   41 
   42 #include <sys/cdefs.h>
   43 __KERNEL_RCSID(0, "$NetBSD: vnode_if.c,v 1.47 2004/01/25 18:06:48 hannken Exp $");
   44 
   45 
   46 /*
   47  * If we have LKM support, always include the non-inline versions for
   48  * LKMs.  Otherwise, do it based on the option.
   49  */
   50 #ifdef LKM
   51 #define VNODE_OP_NOINLINE
   52 #else
   53 #include "opt_vnode_op_noinline.h"
   54 #endif
   55 
   56 #include <sys/param.h>
   57 #include <sys/mount.h>
   58 #include <sys/buf.h>
   59 #include <sys/vnode.h>
   60 
   61 const struct vnodeop_desc vop_default_desc = {
   62         0,
   63         "default",
   64         0,
   65         NULL,
   66         VDESC_NO_OFFSET,
   67         VDESC_NO_OFFSET,
   68         VDESC_NO_OFFSET,
   69         VDESC_NO_OFFSET,
   70         NULL,
   71 };
   72 
   73 
   74 /* Special cases: */
   75 
   76 const int vop_bwrite_vp_offsets[] = {
   77         VDESC_NO_OFFSET
   78 };
   79 const struct vnodeop_desc vop_bwrite_desc = {
   80         1,
   81         "vop_bwrite",
   82         0,
   83         vop_bwrite_vp_offsets,
   84         VDESC_NO_OFFSET,
   85         VDESC_NO_OFFSET,
   86         VDESC_NO_OFFSET,
   87         VDESC_NO_OFFSET,
   88         NULL,
   89 };
   90 #ifdef VNODE_OP_NOINLINE
   91 int
   92 VOP_BWRITE(bp)
   93         struct buf *bp;
   94 {
   95         struct vop_bwrite_args a;
   96         a.a_desc = VDESC(vop_bwrite);
   97         a.a_bp = bp;
   98         return (VCALL(bp->b_vp, VOFFSET(vop_bwrite), &a));
   99 }
  100 #endif
  101 
  102 /* End of special cases */
  103 
  104 const int vop_lookup_vp_offsets[] = {
  105         VOPARG_OFFSETOF(struct vop_lookup_args,a_dvp),
  106         VDESC_NO_OFFSET
  107 };
  108 const struct vnodeop_desc vop_lookup_desc = {
  109         2,
  110         "vop_lookup",
  111         0,
  112         vop_lookup_vp_offsets,
  113         VOPARG_OFFSETOF(struct vop_lookup_args, a_vpp),
  114         VDESC_NO_OFFSET,
  115         VDESC_NO_OFFSET,
  116         VOPARG_OFFSETOF(struct vop_lookup_args, a_cnp),
  117         NULL,
  118 };
  119 #ifdef VNODE_OP_NOINLINE
  120 int
  121 VOP_LOOKUP(dvp, vpp, cnp)
  122         struct vnode *dvp;
  123         struct vnode **vpp;
  124         struct componentname *cnp;
  125 {
  126         struct vop_lookup_args a;
  127         a.a_desc = VDESC(vop_lookup);
  128         a.a_dvp = dvp;
  129         a.a_vpp = vpp;
  130         a.a_cnp = cnp;
  131         return (VCALL(dvp, VOFFSET(vop_lookup), &a));
  132 }
  133 #endif
  134 
  135 const int vop_create_vp_offsets[] = {
  136         VOPARG_OFFSETOF(struct vop_create_args,a_dvp),
  137         VDESC_NO_OFFSET
  138 };
  139 const struct vnodeop_desc vop_create_desc = {
  140         3,
  141         "vop_create",
  142         0 | VDESC_VP0_WILLPUT,
  143         vop_create_vp_offsets,
  144         VOPARG_OFFSETOF(struct vop_create_args, a_vpp),
  145         VDESC_NO_OFFSET,
  146         VDESC_NO_OFFSET,
  147         VOPARG_OFFSETOF(struct vop_create_args, a_cnp),
  148         NULL,
  149 };
  150 #ifdef VNODE_OP_NOINLINE
  151 int
  152 VOP_CREATE(dvp, vpp, cnp, vap)
  153         struct vnode *dvp;
  154         struct vnode **vpp;
  155         struct componentname *cnp;
  156         struct vattr *vap;
  157 {
  158         struct vop_create_args a;
  159         a.a_desc = VDESC(vop_create);
  160         a.a_dvp = dvp;
  161         a.a_vpp = vpp;
  162         a.a_cnp = cnp;
  163         a.a_vap = vap;
  164         return (VCALL(dvp, VOFFSET(vop_create), &a));
  165 }
  166 #endif
  167 
  168 const int vop_mknod_vp_offsets[] = {
  169         VOPARG_OFFSETOF(struct vop_mknod_args,a_dvp),
  170         VDESC_NO_OFFSET
  171 };
  172 const struct vnodeop_desc vop_mknod_desc = {
  173         4,
  174         "vop_mknod",
  175         0 | VDESC_VP0_WILLPUT,
  176         vop_mknod_vp_offsets,
  177         VOPARG_OFFSETOF(struct vop_mknod_args, a_vpp),
  178         VDESC_NO_OFFSET,
  179         VDESC_NO_OFFSET,
  180         VOPARG_OFFSETOF(struct vop_mknod_args, a_cnp),
  181         NULL,
  182 };
  183 #ifdef VNODE_OP_NOINLINE
  184 int
  185 VOP_MKNOD(dvp, vpp, cnp, vap)
  186         struct vnode *dvp;
  187         struct vnode **vpp;
  188         struct componentname *cnp;
  189         struct vattr *vap;
  190 {
  191         struct vop_mknod_args a;
  192         a.a_desc = VDESC(vop_mknod);
  193         a.a_dvp = dvp;
  194         a.a_vpp = vpp;
  195         a.a_cnp = cnp;
  196         a.a_vap = vap;
  197         return (VCALL(dvp, VOFFSET(vop_mknod), &a));
  198 }
  199 #endif
  200 
  201 const int vop_open_vp_offsets[] = {
  202         VOPARG_OFFSETOF(struct vop_open_args,a_vp),
  203         VDESC_NO_OFFSET
  204 };
  205 const struct vnodeop_desc vop_open_desc = {
  206         5,
  207         "vop_open",
  208         0,
  209         vop_open_vp_offsets,
  210         VDESC_NO_OFFSET,
  211         VOPARG_OFFSETOF(struct vop_open_args, a_cred),
  212         VOPARG_OFFSETOF(struct vop_open_args, a_p),
  213         VDESC_NO_OFFSET,
  214         NULL,
  215 };
  216 #ifdef VNODE_OP_NOINLINE
  217 int
  218 VOP_OPEN(vp, mode, cred, p)
  219         struct vnode *vp;
  220         int mode;
  221         struct ucred *cred;
  222         struct proc *p;
  223 {
  224         struct vop_open_args a;
  225         a.a_desc = VDESC(vop_open);
  226         a.a_vp = vp;
  227         a.a_mode = mode;
  228         a.a_cred = cred;
  229         a.a_p = p;
  230         return (VCALL(vp, VOFFSET(vop_open), &a));
  231 }
  232 #endif
  233 
  234 const int vop_close_vp_offsets[] = {
  235         VOPARG_OFFSETOF(struct vop_close_args,a_vp),
  236         VDESC_NO_OFFSET
  237 };
  238 const struct vnodeop_desc vop_close_desc = {
  239         6,
  240         "vop_close",
  241         0,
  242         vop_close_vp_offsets,
  243         VDESC_NO_OFFSET,
  244         VOPARG_OFFSETOF(struct vop_close_args, a_cred),
  245         VOPARG_OFFSETOF(struct vop_close_args, a_p),
  246         VDESC_NO_OFFSET,
  247         NULL,
  248 };
  249 #ifdef VNODE_OP_NOINLINE
  250 int
  251 VOP_CLOSE(vp, fflag, cred, p)
  252         struct vnode *vp;
  253         int fflag;
  254         struct ucred *cred;
  255         struct proc *p;
  256 {
  257         struct vop_close_args a;
  258         a.a_desc = VDESC(vop_close);
  259         a.a_vp = vp;
  260         a.a_fflag = fflag;
  261         a.a_cred = cred;
  262         a.a_p = p;
  263         return (VCALL(vp, VOFFSET(vop_close), &a));
  264 }
  265 #endif
  266 
  267 const int vop_access_vp_offsets[] = {
  268         VOPARG_OFFSETOF(struct vop_access_args,a_vp),
  269         VDESC_NO_OFFSET
  270 };
  271 const struct vnodeop_desc vop_access_desc = {
  272         7,
  273         "vop_access",
  274         0,
  275         vop_access_vp_offsets,
  276         VDESC_NO_OFFSET,
  277         VOPARG_OFFSETOF(struct vop_access_args, a_cred),
  278         VOPARG_OFFSETOF(struct vop_access_args, a_p),
  279         VDESC_NO_OFFSET,
  280         NULL,
  281 };
  282 #ifdef VNODE_OP_NOINLINE
  283 int
  284 VOP_ACCESS(vp, mode, cred, p)
  285         struct vnode *vp;
  286         int mode;
  287         struct ucred *cred;
  288         struct proc *p;
  289 {
  290         struct vop_access_args a;
  291         a.a_desc = VDESC(vop_access);
  292         a.a_vp = vp;
  293         a.a_mode = mode;
  294         a.a_cred = cred;
  295         a.a_p = p;
  296         return (VCALL(vp, VOFFSET(vop_access), &a));
  297 }
  298 #endif
  299 
  300 const int vop_getattr_vp_offsets[] = {
  301         VOPARG_OFFSETOF(struct vop_getattr_args,a_vp),
  302         VDESC_NO_OFFSET
  303 };
  304 const struct vnodeop_desc vop_getattr_desc = {
  305         8,
  306         "vop_getattr",
  307         0,
  308         vop_getattr_vp_offsets,
  309         VDESC_NO_OFFSET,
  310         VOPARG_OFFSETOF(struct vop_getattr_args, a_cred),
  311         VOPARG_OFFSETOF(struct vop_getattr_args, a_p),
  312         VDESC_NO_OFFSET,
  313         NULL,
  314 };
  315 #ifdef VNODE_OP_NOINLINE
  316 int
  317 VOP_GETATTR(vp, vap, cred, p)
  318         struct vnode *vp;
  319         struct vattr *vap;
  320         struct ucred *cred;
  321         struct proc *p;
  322 {
  323         struct vop_getattr_args a;
  324         a.a_desc = VDESC(vop_getattr);
  325         a.a_vp = vp;
  326         a.a_vap = vap;
  327         a.a_cred = cred;
  328         a.a_p = p;
  329         return (VCALL(vp, VOFFSET(vop_getattr), &a));
  330 }
  331 #endif
  332 
  333 const int vop_setattr_vp_offsets[] = {
  334         VOPARG_OFFSETOF(struct vop_setattr_args,a_vp),
  335         VDESC_NO_OFFSET
  336 };
  337 const struct vnodeop_desc vop_setattr_desc = {
  338         9,
  339         "vop_setattr",
  340         0,
  341         vop_setattr_vp_offsets,
  342         VDESC_NO_OFFSET,
  343         VOPARG_OFFSETOF(struct vop_setattr_args, a_cred),
  344         VOPARG_OFFSETOF(struct vop_setattr_args, a_p),
  345         VDESC_NO_OFFSET,
  346         NULL,
  347 };
  348 #ifdef VNODE_OP_NOINLINE
  349 int
  350 VOP_SETATTR(vp, vap, cred, p)
  351         struct vnode *vp;
  352         struct vattr *vap;
  353         struct ucred *cred;
  354         struct proc *p;
  355 {
  356         struct vop_setattr_args a;
  357         a.a_desc = VDESC(vop_setattr);
  358         a.a_vp = vp;
  359         a.a_vap = vap;
  360         a.a_cred = cred;
  361         a.a_p = p;
  362         return (VCALL(vp, VOFFSET(vop_setattr), &a));
  363 }
  364 #endif
  365 
  366 const int vop_read_vp_offsets[] = {
  367         VOPARG_OFFSETOF(struct vop_read_args,a_vp),
  368         VDESC_NO_OFFSET
  369 };
  370 const struct vnodeop_desc vop_read_desc = {
  371         10,
  372         "vop_read",
  373         0,
  374         vop_read_vp_offsets,
  375         VDESC_NO_OFFSET,
  376         VOPARG_OFFSETOF(struct vop_read_args, a_cred),
  377         VDESC_NO_OFFSET,
  378         VDESC_NO_OFFSET,
  379         NULL,
  380 };
  381 #ifdef VNODE_OP_NOINLINE
  382 int
  383 VOP_READ(vp, uio, ioflag, cred)
  384         struct vnode *vp;
  385         struct uio *uio;
  386         int ioflag;
  387         struct ucred *cred;
  388 {
  389         struct vop_read_args a;
  390         a.a_desc = VDESC(vop_read);
  391         a.a_vp = vp;
  392         a.a_uio = uio;
  393         a.a_ioflag = ioflag;
  394         a.a_cred = cred;
  395         return (VCALL(vp, VOFFSET(vop_read), &a));
  396 }
  397 #endif
  398 
  399 const int vop_write_vp_offsets[] = {
  400         VOPARG_OFFSETOF(struct vop_write_args,a_vp),
  401         VDESC_NO_OFFSET
  402 };
  403 const struct vnodeop_desc vop_write_desc = {
  404         11,
  405         "vop_write",
  406         0,
  407         vop_write_vp_offsets,
  408         VDESC_NO_OFFSET,
  409         VOPARG_OFFSETOF(struct vop_write_args, a_cred),
  410         VDESC_NO_OFFSET,
  411         VDESC_NO_OFFSET,
  412         NULL,
  413 };
  414 #ifdef VNODE_OP_NOINLINE
  415 int
  416 VOP_WRITE(vp, uio, ioflag, cred)
  417         struct vnode *vp;
  418         struct uio *uio;
  419         int ioflag;
  420         struct ucred *cred;
  421 {
  422         struct vop_write_args a;
  423         a.a_desc = VDESC(vop_write);
  424         a.a_vp = vp;
  425         a.a_uio = uio;
  426         a.a_ioflag = ioflag;
  427         a.a_cred = cred;
  428         return (VCALL(vp, VOFFSET(vop_write), &a));
  429 }
  430 #endif
  431 
  432 const int vop_ioctl_vp_offsets[] = {
  433         VOPARG_OFFSETOF(struct vop_ioctl_args,a_vp),
  434         VDESC_NO_OFFSET
  435 };
  436 const struct vnodeop_desc vop_ioctl_desc = {
  437         12,
  438         "vop_ioctl",
  439         0,
  440         vop_ioctl_vp_offsets,
  441         VDESC_NO_OFFSET,
  442         VOPARG_OFFSETOF(struct vop_ioctl_args, a_cred),
  443         VOPARG_OFFSETOF(struct vop_ioctl_args, a_p),
  444         VDESC_NO_OFFSET,
  445         NULL,
  446 };
  447 #ifdef VNODE_OP_NOINLINE
  448 int
  449 VOP_IOCTL(vp, command, data, fflag, cred, p)
  450         struct vnode *vp;
  451         u_long command;
  452         void *data;
  453         int fflag;
  454         struct ucred *cred;
  455         struct proc *p;
  456 {
  457         struct vop_ioctl_args a;
  458         a.a_desc = VDESC(vop_ioctl);
  459         a.a_vp = vp;
  460         a.a_command = command;
  461         a.a_data = data;
  462         a.a_fflag = fflag;
  463         a.a_cred = cred;
  464         a.a_p = p;
  465         return (VCALL(vp, VOFFSET(vop_ioctl), &a));
  466 }
  467 #endif
  468 
  469 const int vop_fcntl_vp_offsets[] = {
  470         VOPARG_OFFSETOF(struct vop_fcntl_args,a_vp),
  471         VDESC_NO_OFFSET
  472 };
  473 const struct vnodeop_desc vop_fcntl_desc = {
  474         13,
  475         "vop_fcntl",
  476         0,
  477         vop_fcntl_vp_offsets,
  478         VDESC_NO_OFFSET,
  479         VOPARG_OFFSETOF(struct vop_fcntl_args, a_cred),
  480         VOPARG_OFFSETOF(struct vop_fcntl_args, a_p),
  481         VDESC_NO_OFFSET,
  482         NULL,
  483 };
  484 #ifdef VNODE_OP_NOINLINE
  485 int
  486 VOP_FCNTL(vp, command, data, fflag, cred, p)
  487         struct vnode *vp;
  488         u_int command;
  489         void *data;
  490         int fflag;
  491         struct ucred *cred;
  492         struct proc *p;
  493 {
  494         struct vop_fcntl_args a;
  495         a.a_desc = VDESC(vop_fcntl);
  496         a.a_vp = vp;
  497         a.a_command = command;
  498         a.a_data = data;
  499         a.a_fflag = fflag;
  500         a.a_cred = cred;
  501         a.a_p = p;
  502         return (VCALL(vp, VOFFSET(vop_fcntl), &a));
  503 }
  504 #endif
  505 
  506 const int vop_poll_vp_offsets[] = {
  507         VOPARG_OFFSETOF(struct vop_poll_args,a_vp),
  508         VDESC_NO_OFFSET
  509 };
  510 const struct vnodeop_desc vop_poll_desc = {
  511         14,
  512         "vop_poll",
  513         0,
  514         vop_poll_vp_offsets,
  515         VDESC_NO_OFFSET,
  516         VDESC_NO_OFFSET,
  517         VOPARG_OFFSETOF(struct vop_poll_args, a_p),
  518         VDESC_NO_OFFSET,
  519         NULL,
  520 };
  521 #ifdef VNODE_OP_NOINLINE
  522 int
  523 VOP_POLL(vp, events, p)
  524         struct vnode *vp;
  525         int events;
  526         struct proc *p;
  527 {
  528         struct vop_poll_args a;
  529         a.a_desc = VDESC(vop_poll);
  530         a.a_vp = vp;
  531         a.a_events = events;
  532         a.a_p = p;
  533         return (VCALL(vp, VOFFSET(vop_poll), &a));
  534 }
  535 #endif
  536 
  537 const int vop_kqfilter_vp_offsets[] = {
  538         VOPARG_OFFSETOF(struct vop_kqfilter_args,a_vp),
  539         VDESC_NO_OFFSET
  540 };
  541 const struct vnodeop_desc vop_kqfilter_desc = {
  542         15,
  543         "vop_kqfilter",
  544         0,
  545         vop_kqfilter_vp_offsets,
  546         VDESC_NO_OFFSET,
  547         VDESC_NO_OFFSET,
  548         VDESC_NO_OFFSET,
  549         VDESC_NO_OFFSET,
  550         NULL,
  551 };
  552 #ifdef VNODE_OP_NOINLINE
  553 int
  554 VOP_KQFILTER(vp, kn)
  555         struct vnode *vp;
  556         struct knote *kn;
  557 {
  558         struct vop_kqfilter_args a;
  559         a.a_desc = VDESC(vop_kqfilter);
  560         a.a_vp = vp;
  561         a.a_kn = kn;
  562         return (VCALL(vp, VOFFSET(vop_kqfilter), &a));
  563 }
  564 #endif
  565 
  566 const int vop_revoke_vp_offsets[] = {
  567         VOPARG_OFFSETOF(struct vop_revoke_args,a_vp),
  568         VDESC_NO_OFFSET
  569 };
  570 const struct vnodeop_desc vop_revoke_desc = {
  571         16,
  572         "vop_revoke",
  573         0,
  574         vop_revoke_vp_offsets,
  575         VDESC_NO_OFFSET,
  576         VDESC_NO_OFFSET,
  577         VDESC_NO_OFFSET,
  578         VDESC_NO_OFFSET,
  579         NULL,
  580 };
  581 #ifdef VNODE_OP_NOINLINE
  582 int
  583 VOP_REVOKE(vp, flags)
  584         struct vnode *vp;
  585         int flags;
  586 {
  587         struct vop_revoke_args a;
  588         a.a_desc = VDESC(vop_revoke);
  589         a.a_vp = vp;
  590         a.a_flags = flags;
  591         return (VCALL(vp, VOFFSET(vop_revoke), &a));
  592 }
  593 #endif
  594 
  595 const int vop_mmap_vp_offsets[] = {
  596         VOPARG_OFFSETOF(struct vop_mmap_args,a_vp),
  597         VDESC_NO_OFFSET
  598 };
  599 const struct vnodeop_desc vop_mmap_desc = {
  600         17,
  601         "vop_mmap",
  602         0,
  603         vop_mmap_vp_offsets,
  604         VDESC_NO_OFFSET,
  605         VOPARG_OFFSETOF(struct vop_mmap_args, a_cred),
  606         VOPARG_OFFSETOF(struct vop_mmap_args, a_p),
  607         VDESC_NO_OFFSET,
  608         NULL,
  609 };
  610 #ifdef VNODE_OP_NOINLINE
  611 int
  612 VOP_MMAP(vp, fflags, cred, p)
  613         struct vnode *vp;
  614         int fflags;
  615         struct ucred *cred;
  616         struct proc *p;
  617 {
  618         struct vop_mmap_args a;
  619         a.a_desc = VDESC(vop_mmap);
  620         a.a_vp = vp;
  621         a.a_fflags = fflags;
  622         a.a_cred = cred;
  623         a.a_p = p;
  624         return (VCALL(vp, VOFFSET(vop_mmap), &a));
  625 }
  626 #endif
  627 
  628 const int vop_fsync_vp_offsets[] = {
  629         VOPARG_OFFSETOF(struct vop_fsync_args,a_vp),
  630         VDESC_NO_OFFSET
  631 };
  632 const struct vnodeop_desc vop_fsync_desc = {
  633         18,
  634         "vop_fsync",
  635         0,
  636         vop_fsync_vp_offsets,
  637         VDESC_NO_OFFSET,
  638         VOPARG_OFFSETOF(struct vop_fsync_args, a_cred),
  639         VOPARG_OFFSETOF(struct vop_fsync_args, a_p),
  640         VDESC_NO_OFFSET,
  641         NULL,
  642 };
  643 #ifdef VNODE_OP_NOINLINE
  644 int
  645 VOP_FSYNC(vp, cred, flags, offlo, offhi, p)
  646         struct vnode *vp;
  647         struct ucred *cred;
  648         int flags;
  649         off_t offlo;
  650         off_t offhi;
  651         struct proc *p;
  652 {
  653         struct vop_fsync_args a;
  654         a.a_desc = VDESC(vop_fsync);
  655         a.a_vp = vp;
  656         a.a_cred = cred;
  657         a.a_flags = flags;
  658         a.a_offlo = offlo;
  659         a.a_offhi = offhi;
  660         a.a_p = p;
  661         return (VCALL(vp, VOFFSET(vop_fsync), &a));
  662 }
  663 #endif
  664 
  665 const int vop_seek_vp_offsets[] = {
  666         VOPARG_OFFSETOF(struct vop_seek_args,a_vp),
  667         VDESC_NO_OFFSET
  668 };
  669 const struct vnodeop_desc vop_seek_desc = {
  670         19,
  671         "vop_seek",
  672         0,
  673         vop_seek_vp_offsets,
  674         VDESC_NO_OFFSET,
  675         VOPARG_OFFSETOF(struct vop_seek_args, a_cred),
  676         VDESC_NO_OFFSET,
  677         VDESC_NO_OFFSET,
  678         NULL,
  679 };
  680 #ifdef VNODE_OP_NOINLINE
  681 int
  682 VOP_SEEK(vp, oldoff, newoff, cred)
  683         struct vnode *vp;
  684         off_t oldoff;
  685         off_t newoff;
  686         struct ucred *cred;
  687 {
  688         struct vop_seek_args a;
  689         a.a_desc = VDESC(vop_seek);
  690         a.a_vp = vp;
  691         a.a_oldoff = oldoff;
  692         a.a_newoff = newoff;
  693         a.a_cred = cred;
  694         return (VCALL(vp, VOFFSET(vop_seek), &a));
  695 }
  696 #endif
  697 
  698 const int vop_remove_vp_offsets[] = {
  699         VOPARG_OFFSETOF(struct vop_remove_args,a_dvp),
  700         VOPARG_OFFSETOF(struct vop_remove_args,a_vp),
  701         VDESC_NO_OFFSET
  702 };
  703 const struct vnodeop_desc vop_remove_desc = {
  704         20,
  705         "vop_remove",
  706         0 | VDESC_VP0_WILLPUT | VDESC_VP1_WILLPUT,
  707         vop_remove_vp_offsets,
  708         VDESC_NO_OFFSET,
  709         VDESC_NO_OFFSET,
  710         VDESC_NO_OFFSET,
  711         VOPARG_OFFSETOF(struct vop_remove_args, a_cnp),
  712         NULL,
  713 };
  714 #ifdef VNODE_OP_NOINLINE
  715 int
  716 VOP_REMOVE(dvp, vp, cnp)
  717         struct vnode *dvp;
  718         struct vnode *vp;
  719         struct componentname *cnp;
  720 {
  721         struct vop_remove_args a;
  722         a.a_desc = VDESC(vop_remove);
  723         a.a_dvp = dvp;
  724         a.a_vp = vp;
  725         a.a_cnp = cnp;
  726         return (VCALL(dvp, VOFFSET(vop_remove), &a));
  727 }
  728 #endif
  729 
  730 const int vop_link_vp_offsets[] = {
  731         VOPARG_OFFSETOF(struct vop_link_args,a_dvp),
  732         VOPARG_OFFSETOF(struct vop_link_args,a_vp),
  733         VDESC_NO_OFFSET
  734 };
  735 const struct vnodeop_desc vop_link_desc = {
  736         21,
  737         "vop_link",
  738         0 | VDESC_VP0_WILLPUT,
  739         vop_link_vp_offsets,
  740         VDESC_NO_OFFSET,
  741         VDESC_NO_OFFSET,
  742         VDESC_NO_OFFSET,
  743         VOPARG_OFFSETOF(struct vop_link_args, a_cnp),
  744         NULL,
  745 };
  746 #ifdef VNODE_OP_NOINLINE
  747 int
  748 VOP_LINK(dvp, vp, cnp)
  749         struct vnode *dvp;
  750         struct vnode *vp;
  751         struct componentname *cnp;
  752 {
  753         struct vop_link_args a;
  754         a.a_desc = VDESC(vop_link);
  755         a.a_dvp = dvp;
  756         a.a_vp = vp;
  757         a.a_cnp = cnp;
  758         return (VCALL(dvp, VOFFSET(vop_link), &a));
  759 }
  760 #endif
  761 
  762 const int vop_rename_vp_offsets[] = {
  763         VOPARG_OFFSETOF(struct vop_rename_args,a_fdvp),
  764         VOPARG_OFFSETOF(struct vop_rename_args,a_fvp),
  765         VOPARG_OFFSETOF(struct vop_rename_args,a_tdvp),
  766         VOPARG_OFFSETOF(struct vop_rename_args,a_tvp),
  767         VDESC_NO_OFFSET
  768 };
  769 const struct vnodeop_desc vop_rename_desc = {
  770         22,
  771         "vop_rename",
  772         0 | VDESC_VP0_WILLRELE | VDESC_VP1_WILLRELE | VDESC_VP2_WILLPUT | VDESC_VP3_WILLPUT,
  773         vop_rename_vp_offsets,
  774         VDESC_NO_OFFSET,
  775         VDESC_NO_OFFSET,
  776         VDESC_NO_OFFSET,
  777         VOPARG_OFFSETOF(struct vop_rename_args, a_fcnp),
  778         NULL,
  779 };
  780 #ifdef VNODE_OP_NOINLINE
  781 int
  782 VOP_RENAME(fdvp, fvp, fcnp, tdvp, tvp, tcnp)
  783         struct vnode *fdvp;
  784         struct vnode *fvp;
  785         struct componentname *fcnp;
  786         struct vnode *tdvp;
  787         struct vnode *tvp;
  788         struct componentname *tcnp;
  789 {
  790         struct vop_rename_args a;
  791         a.a_desc = VDESC(vop_rename);
  792         a.a_fdvp = fdvp;
  793         a.a_fvp = fvp;
  794         a.a_fcnp = fcnp;
  795         a.a_tdvp = tdvp;
  796         a.a_tvp = tvp;
  797         a.a_tcnp = tcnp;
  798         return (VCALL(fdvp, VOFFSET(vop_rename), &a));
  799 }
  800 #endif
  801 
  802 const int vop_mkdir_vp_offsets[] = {
  803         VOPARG_OFFSETOF(struct vop_mkdir_args,a_dvp),
  804         VDESC_NO_OFFSET
  805 };
  806 const struct vnodeop_desc vop_mkdir_desc = {
  807         23,
  808         "vop_mkdir",
  809         0 | VDESC_VP0_WILLPUT,
  810         vop_mkdir_vp_offsets,
  811         VOPARG_OFFSETOF(struct vop_mkdir_args, a_vpp),
  812         VDESC_NO_OFFSET,
  813         VDESC_NO_OFFSET,
  814         VOPARG_OFFSETOF(struct vop_mkdir_args, a_cnp),
  815         NULL,
  816 };
  817 #ifdef VNODE_OP_NOINLINE
  818 int
  819 VOP_MKDIR(dvp, vpp, cnp, vap)
  820         struct vnode *dvp;
  821         struct vnode **vpp;
  822         struct componentname *cnp;
  823         struct vattr *vap;
  824 {
  825         struct vop_mkdir_args a;
  826         a.a_desc = VDESC(vop_mkdir);
  827         a.a_dvp = dvp;
  828         a.a_vpp = vpp;
  829         a.a_cnp = cnp;
  830         a.a_vap = vap;
  831         return (VCALL(dvp, VOFFSET(vop_mkdir), &a));
  832 }
  833 #endif
  834 
  835 const int vop_rmdir_vp_offsets[] = {
  836         VOPARG_OFFSETOF(struct vop_rmdir_args,a_dvp),
  837         VOPARG_OFFSETOF(struct vop_rmdir_args,a_vp),
  838         VDESC_NO_OFFSET
  839 };
  840 const struct vnodeop_desc vop_rmdir_desc = {
  841         24,
  842         "vop_rmdir",
  843         0 | VDESC_VP0_WILLPUT | VDESC_VP1_WILLPUT,
  844         vop_rmdir_vp_offsets,
  845         VDESC_NO_OFFSET,
  846         VDESC_NO_OFFSET,
  847         VDESC_NO_OFFSET,
  848         VOPARG_OFFSETOF(struct vop_rmdir_args, a_cnp),
  849         NULL,
  850 };
  851 #ifdef VNODE_OP_NOINLINE
  852 int
  853 VOP_RMDIR(dvp, vp, cnp)
  854         struct vnode *dvp;
  855         struct vnode *vp;
  856         struct componentname *cnp;
  857 {
  858         struct vop_rmdir_args a;
  859         a.a_desc = VDESC(vop_rmdir);
  860         a.a_dvp = dvp;
  861         a.a_vp = vp;
  862         a.a_cnp = cnp;
  863         return (VCALL(dvp, VOFFSET(vop_rmdir), &a));
  864 }
  865 #endif
  866 
  867 const int vop_symlink_vp_offsets[] = {
  868         VOPARG_OFFSETOF(struct vop_symlink_args,a_dvp),
  869         VDESC_NO_OFFSET
  870 };
  871 const struct vnodeop_desc vop_symlink_desc = {
  872         25,
  873         "vop_symlink",
  874         0 | VDESC_VP0_WILLPUT,
  875         vop_symlink_vp_offsets,
  876         VOPARG_OFFSETOF(struct vop_symlink_args, a_vpp),
  877         VDESC_NO_OFFSET,
  878         VDESC_NO_OFFSET,
  879         VOPARG_OFFSETOF(struct vop_symlink_args, a_cnp),
  880         NULL,
  881 };
  882 #ifdef VNODE_OP_NOINLINE
  883 int
  884 VOP_SYMLINK(dvp, vpp, cnp, vap, target)
  885         struct vnode *dvp;
  886         struct vnode **vpp;
  887         struct componentname *cnp;
  888         struct vattr *vap;
  889         char *target;
  890 {
  891         struct vop_symlink_args a;
  892         a.a_desc = VDESC(vop_symlink);
  893         a.a_dvp = dvp;
  894         a.a_vpp = vpp;
  895         a.a_cnp = cnp;
  896         a.a_vap = vap;
  897         a.a_target = target;
  898         return (VCALL(dvp, VOFFSET(vop_symlink), &a));
  899 }
  900 #endif
  901 
  902 const int vop_readdir_vp_offsets[] = {
  903         VOPARG_OFFSETOF(struct vop_readdir_args,a_vp),
  904         VDESC_NO_OFFSET
  905 };
  906 const struct vnodeop_desc vop_readdir_desc = {
  907         26,
  908         "vop_readdir",
  909         0,
  910         vop_readdir_vp_offsets,
  911         VDESC_NO_OFFSET,
  912         VOPARG_OFFSETOF(struct vop_readdir_args, a_cred),
  913         VDESC_NO_OFFSET,
  914         VDESC_NO_OFFSET,
  915         NULL,
  916 };
  917 #ifdef VNODE_OP_NOINLINE
  918 int
  919 VOP_READDIR(vp, uio, cred, eofflag, cookies, ncookies)
  920         struct vnode *vp;
  921         struct uio *uio;
  922         struct ucred *cred;
  923         int *eofflag;
  924         off_t **cookies;
  925         int *ncookies;
  926 {
  927         struct vop_readdir_args a;
  928         a.a_desc = VDESC(vop_readdir);
  929         a.a_vp = vp;
  930         a.a_uio = uio;
  931         a.a_cred = cred;
  932         a.a_eofflag = eofflag;
  933         a.a_cookies = cookies;
  934         a.a_ncookies = ncookies;
  935         return (VCALL(vp, VOFFSET(vop_readdir), &a));
  936 }
  937 #endif
  938 
  939 const int vop_readlink_vp_offsets[] = {
  940         VOPARG_OFFSETOF(struct vop_readlink_args,a_vp),
  941         VDESC_NO_OFFSET
  942 };
  943 const struct vnodeop_desc vop_readlink_desc = {
  944         27,
  945         "vop_readlink",
  946         0,
  947         vop_readlink_vp_offsets,
  948         VDESC_NO_OFFSET,
  949         VOPARG_OFFSETOF(struct vop_readlink_args, a_cred),
  950         VDESC_NO_OFFSET,
  951         VDESC_NO_OFFSET,
  952         NULL,
  953 };
  954 #ifdef VNODE_OP_NOINLINE
  955 int
  956 VOP_READLINK(vp, uio, cred)
  957         struct vnode *vp;
  958         struct uio *uio;
  959         struct ucred *cred;
  960 {
  961         struct vop_readlink_args a;
  962         a.a_desc = VDESC(vop_readlink);
  963         a.a_vp = vp;
  964         a.a_uio = uio;
  965         a.a_cred = cred;
  966         return (VCALL(vp, VOFFSET(vop_readlink), &a));
  967 }
  968 #endif
  969 
  970 const int vop_abortop_vp_offsets[] = {
  971         VOPARG_OFFSETOF(struct vop_abortop_args,a_dvp),
  972         VDESC_NO_OFFSET
  973 };
  974 const struct vnodeop_desc vop_abortop_desc = {
  975         28,
  976         "vop_abortop",
  977         0,
  978         vop_abortop_vp_offsets,
  979         VDESC_NO_OFFSET,
  980         VDESC_NO_OFFSET,
  981         VDESC_NO_OFFSET,
  982         VOPARG_OFFSETOF(struct vop_abortop_args, a_cnp),
  983         NULL,
  984 };
  985 #ifdef VNODE_OP_NOINLINE
  986 int
  987 VOP_ABORTOP(dvp, cnp)
  988         struct vnode *dvp;
  989         struct componentname *cnp;
  990 {
  991         struct vop_abortop_args a;
  992         a.a_desc = VDESC(vop_abortop);
  993         a.a_dvp = dvp;
  994         a.a_cnp = cnp;
  995         return (VCALL(dvp, VOFFSET(vop_abortop), &a));
  996 }
  997 #endif
  998 
  999 const int vop_inactive_vp_offsets[] = {
 1000         VOPARG_OFFSETOF(struct vop_inactive_args,a_vp),
 1001         VDESC_NO_OFFSET
 1002 };
 1003 const struct vnodeop_desc vop_inactive_desc = {
 1004         29,
 1005         "vop_inactive",
 1006         0 | VDESC_VP0_WILLUNLOCK,
 1007         vop_inactive_vp_offsets,
 1008         VDESC_NO_OFFSET,
 1009         VDESC_NO_OFFSET,
 1010         VOPARG_OFFSETOF(struct vop_inactive_args, a_p),
 1011         VDESC_NO_OFFSET,
 1012         NULL,
 1013 };
 1014 #ifdef VNODE_OP_NOINLINE
 1015 int
 1016 VOP_INACTIVE(vp, p)
 1017         struct vnode *vp;
 1018         struct proc *p;
 1019 {
 1020         struct vop_inactive_args a;
 1021         a.a_desc = VDESC(vop_inactive);
 1022         a.a_vp = vp;
 1023         a.a_p = p;
 1024         return (VCALL(vp, VOFFSET(vop_inactive), &a));
 1025 }
 1026 #endif
 1027 
 1028 const int vop_reclaim_vp_offsets[] = {
 1029         VOPARG_OFFSETOF(struct vop_reclaim_args,a_vp),
 1030         VDESC_NO_OFFSET
 1031 };
 1032 const struct vnodeop_desc vop_reclaim_desc = {
 1033         30,
 1034         "vop_reclaim",
 1035         0,
 1036         vop_reclaim_vp_offsets,
 1037         VDESC_NO_OFFSET,
 1038         VDESC_NO_OFFSET,
 1039         VOPARG_OFFSETOF(struct vop_reclaim_args, a_p),
 1040         VDESC_NO_OFFSET,
 1041         NULL,
 1042 };
 1043 #ifdef VNODE_OP_NOINLINE
 1044 int
 1045 VOP_RECLAIM(vp, p)
 1046         struct vnode *vp;
 1047         struct proc *p;
 1048 {
 1049         struct vop_reclaim_args a;
 1050         a.a_desc = VDESC(vop_reclaim);
 1051         a.a_vp = vp;
 1052         a.a_p = p;
 1053         return (VCALL(vp, VOFFSET(vop_reclaim), &a));
 1054 }
 1055 #endif
 1056 
 1057 const int vop_lock_vp_offsets[] = {
 1058         VOPARG_OFFSETOF(struct vop_lock_args,a_vp),
 1059         VDESC_NO_OFFSET
 1060 };
 1061 const struct vnodeop_desc vop_lock_desc = {
 1062         31,
 1063         "vop_lock",
 1064         0,
 1065         vop_lock_vp_offsets,
 1066         VDESC_NO_OFFSET,
 1067         VDESC_NO_OFFSET,
 1068         VDESC_NO_OFFSET,
 1069         VDESC_NO_OFFSET,
 1070         NULL,
 1071 };
 1072 #ifdef VNODE_OP_NOINLINE
 1073 int
 1074 VOP_LOCK(vp, flags)
 1075         struct vnode *vp;
 1076         int flags;
 1077 {
 1078         struct vop_lock_args a;
 1079         a.a_desc = VDESC(vop_lock);
 1080         a.a_vp = vp;
 1081         a.a_flags = flags;
 1082         return (VCALL(vp, VOFFSET(vop_lock), &a));
 1083 }
 1084 #endif
 1085 
 1086 const int vop_unlock_vp_offsets[] = {
 1087         VOPARG_OFFSETOF(struct vop_unlock_args,a_vp),
 1088         VDESC_NO_OFFSET
 1089 };
 1090 const struct vnodeop_desc vop_unlock_desc = {
 1091         32,
 1092         "vop_unlock",
 1093         0,
 1094         vop_unlock_vp_offsets,
 1095         VDESC_NO_OFFSET,
 1096         VDESC_NO_OFFSET,
 1097         VDESC_NO_OFFSET,
 1098         VDESC_NO_OFFSET,
 1099         NULL,
 1100 };
 1101 #ifdef VNODE_OP_NOINLINE
 1102 int
 1103 VOP_UNLOCK(vp, flags)
 1104         struct vnode *vp;
 1105         int flags;
 1106 {
 1107         struct vop_unlock_args a;
 1108         a.a_desc = VDESC(vop_unlock);
 1109         a.a_vp = vp;
 1110         a.a_flags = flags;
 1111         return (VCALL(vp, VOFFSET(vop_unlock), &a));
 1112 }
 1113 #endif
 1114 
 1115 const int vop_bmap_vp_offsets[] = {
 1116         VOPARG_OFFSETOF(struct vop_bmap_args,a_vp),
 1117         VDESC_NO_OFFSET
 1118 };
 1119 const struct vnodeop_desc vop_bmap_desc = {
 1120         33,
 1121         "vop_bmap",
 1122         0,
 1123         vop_bmap_vp_offsets,
 1124         VOPARG_OFFSETOF(struct vop_bmap_args, a_vpp),
 1125         VDESC_NO_OFFSET,
 1126         VDESC_NO_OFFSET,
 1127         VDESC_NO_OFFSET,
 1128         NULL,
 1129 };
 1130 #ifdef VNODE_OP_NOINLINE
 1131 int
 1132 VOP_BMAP(vp, bn, vpp, bnp, runp)
 1133         struct vnode *vp;
 1134         daddr_t bn;
 1135         struct vnode **vpp;
 1136         daddr_t *bnp;
 1137         int *runp;
 1138 {
 1139         struct vop_bmap_args a;
 1140         a.a_desc = VDESC(vop_bmap);
 1141         a.a_vp = vp;
 1142         a.a_bn = bn;
 1143         a.a_vpp = vpp;
 1144         a.a_bnp = bnp;
 1145         a.a_runp = runp;
 1146         return (VCALL(vp, VOFFSET(vop_bmap), &a));
 1147 }
 1148 #endif
 1149 
 1150 const int vop_strategy_vp_offsets[] = {
 1151         VOPARG_OFFSETOF(struct vop_strategy_args,a_vp),
 1152         VDESC_NO_OFFSET
 1153 };
 1154 const struct vnodeop_desc vop_strategy_desc = {
 1155         34,
 1156         "vop_strategy",
 1157         0,
 1158         vop_strategy_vp_offsets,
 1159         VDESC_NO_OFFSET,
 1160         VDESC_NO_OFFSET,
 1161         VDESC_NO_OFFSET,
 1162         VDESC_NO_OFFSET,
 1163         NULL,
 1164 };
 1165 #ifdef VNODE_OP_NOINLINE
 1166 int
 1167 VOP_STRATEGY(vp, bp)
 1168         struct vnode *vp;
 1169         struct buf *bp;
 1170 {
 1171         struct vop_strategy_args a;
 1172         a.a_desc = VDESC(vop_strategy);
 1173         a.a_vp = vp;
 1174         a.a_bp = bp;
 1175         return (VCALL(vp, VOFFSET(vop_strategy), &a));
 1176 }
 1177 #endif
 1178 
 1179 const int vop_print_vp_offsets[] = {
 1180         VOPARG_OFFSETOF(struct vop_print_args,a_vp),
 1181         VDESC_NO_OFFSET
 1182 };
 1183 const struct vnodeop_desc vop_print_desc = {
 1184         35,
 1185         "vop_print",
 1186         0,
 1187         vop_print_vp_offsets,
 1188         VDESC_NO_OFFSET,
 1189         VDESC_NO_OFFSET,
 1190         VDESC_NO_OFFSET,
 1191         VDESC_NO_OFFSET,
 1192         NULL,
 1193 };
 1194 #ifdef VNODE_OP_NOINLINE
 1195 int
 1196 VOP_PRINT(vp)
 1197         struct vnode *vp;
 1198 {
 1199         struct vop_print_args a;
 1200         a.a_desc = VDESC(vop_print);
 1201         a.a_vp = vp;
 1202         return (VCALL(vp, VOFFSET(vop_print), &a));
 1203 }
 1204 #endif
 1205 
 1206 const int vop_islocked_vp_offsets[] = {
 1207         VOPARG_OFFSETOF(struct vop_islocked_args,a_vp),
 1208         VDESC_NO_OFFSET
 1209 };
 1210 const struct vnodeop_desc vop_islocked_desc = {
 1211         36,
 1212         "vop_islocked",
 1213         0,
 1214         vop_islocked_vp_offsets,
 1215         VDESC_NO_OFFSET,
 1216         VDESC_NO_OFFSET,
 1217         VDESC_NO_OFFSET,
 1218         VDESC_NO_OFFSET,
 1219         NULL,
 1220 };
 1221 #ifdef VNODE_OP_NOINLINE
 1222 int
 1223 VOP_ISLOCKED(vp)
 1224         struct vnode *vp;
 1225 {
 1226         struct vop_islocked_args a;
 1227         a.a_desc = VDESC(vop_islocked);
 1228         a.a_vp = vp;
 1229         return (VCALL(vp, VOFFSET(vop_islocked), &a));
 1230 }
 1231 #endif
 1232 
 1233 const int vop_pathconf_vp_offsets[] = {
 1234         VOPARG_OFFSETOF(struct vop_pathconf_args,a_vp),
 1235         VDESC_NO_OFFSET
 1236 };
 1237 const struct vnodeop_desc vop_pathconf_desc = {
 1238         37,
 1239         "vop_pathconf",
 1240         0,
 1241         vop_pathconf_vp_offsets,
 1242         VDESC_NO_OFFSET,
 1243         VDESC_NO_OFFSET,
 1244         VDESC_NO_OFFSET,
 1245         VDESC_NO_OFFSET,
 1246         NULL,
 1247 };
 1248 #ifdef VNODE_OP_NOINLINE
 1249 int
 1250 VOP_PATHCONF(vp, name, retval)
 1251         struct vnode *vp;
 1252         int name;
 1253         register_t *retval;
 1254 {
 1255         struct vop_pathconf_args a;
 1256         a.a_desc = VDESC(vop_pathconf);
 1257         a.a_vp = vp;
 1258         a.a_name = name;
 1259         a.a_retval = retval;
 1260         return (VCALL(vp, VOFFSET(vop_pathconf), &a));
 1261 }
 1262 #endif
 1263 
 1264 const int vop_advlock_vp_offsets[] = {
 1265         VOPARG_OFFSETOF(struct vop_advlock_args,a_vp),
 1266         VDESC_NO_OFFSET
 1267 };
 1268 const struct vnodeop_desc vop_advlock_desc = {
 1269         38,
 1270         "vop_advlock",
 1271         0,
 1272         vop_advlock_vp_offsets,
 1273         VDESC_NO_OFFSET,
 1274         VDESC_NO_OFFSET,
 1275         VDESC_NO_OFFSET,
 1276         VDESC_NO_OFFSET,
 1277         NULL,
 1278 };
 1279 #ifdef VNODE_OP_NOINLINE
 1280 int
 1281 VOP_ADVLOCK(vp, id, op, fl, flags)
 1282         struct vnode *vp;
 1283         void *id;
 1284         int op;
 1285         struct flock *fl;
 1286         int flags;
 1287 {
 1288         struct vop_advlock_args a;
 1289         a.a_desc = VDESC(vop_advlock);
 1290         a.a_vp = vp;
 1291         a.a_id = id;
 1292         a.a_op = op;
 1293         a.a_fl = fl;
 1294         a.a_flags = flags;
 1295         return (VCALL(vp, VOFFSET(vop_advlock), &a));
 1296 }
 1297 #endif
 1298 
 1299 const int vop_blkatoff_vp_offsets[] = {
 1300         VOPARG_OFFSETOF(struct vop_blkatoff_args,a_vp),
 1301         VDESC_NO_OFFSET
 1302 };
 1303 const struct vnodeop_desc vop_blkatoff_desc = {
 1304         39,
 1305         "vop_blkatoff",
 1306         0,
 1307         vop_blkatoff_vp_offsets,
 1308         VDESC_NO_OFFSET,
 1309         VDESC_NO_OFFSET,
 1310         VDESC_NO_OFFSET,
 1311         VDESC_NO_OFFSET,
 1312         NULL,
 1313 };
 1314 #ifdef VNODE_OP_NOINLINE
 1315 int
 1316 VOP_BLKATOFF(vp, offset, res, bpp)
 1317         struct vnode *vp;
 1318         off_t offset;
 1319         char **res;
 1320         struct buf **bpp;
 1321 {
 1322         struct vop_blkatoff_args a;
 1323         a.a_desc = VDESC(vop_blkatoff);
 1324         a.a_vp = vp;
 1325         a.a_offset = offset;
 1326         a.a_res = res;
 1327         a.a_bpp = bpp;
 1328         return (VCALL(vp, VOFFSET(vop_blkatoff), &a));
 1329 }
 1330 #endif
 1331 
 1332 const int vop_valloc_vp_offsets[] = {
 1333         VOPARG_OFFSETOF(struct vop_valloc_args,a_pvp),
 1334         VDESC_NO_OFFSET
 1335 };
 1336 const struct vnodeop_desc vop_valloc_desc = {
 1337         40,
 1338         "vop_valloc",
 1339         0,
 1340         vop_valloc_vp_offsets,
 1341         VOPARG_OFFSETOF(struct vop_valloc_args, a_vpp),
 1342         VOPARG_OFFSETOF(struct vop_valloc_args, a_cred),
 1343         VDESC_NO_OFFSET,
 1344         VDESC_NO_OFFSET,
 1345         NULL,
 1346 };
 1347 #ifdef VNODE_OP_NOINLINE
 1348 int
 1349 VOP_VALLOC(pvp, mode, cred, vpp)
 1350         struct vnode *pvp;
 1351         int mode;
 1352         struct ucred *cred;
 1353         struct vnode **vpp;
 1354 {
 1355         struct vop_valloc_args a;
 1356         a.a_desc = VDESC(vop_valloc);
 1357         a.a_pvp = pvp;
 1358         a.a_mode = mode;
 1359         a.a_cred = cred;
 1360         a.a_vpp = vpp;
 1361         return (VCALL(pvp, VOFFSET(vop_valloc), &a));
 1362 }
 1363 #endif
 1364 
 1365 const int vop_balloc_vp_offsets[] = {
 1366         VOPARG_OFFSETOF(struct vop_balloc_args,a_vp),
 1367         VDESC_NO_OFFSET
 1368 };
 1369 const struct vnodeop_desc vop_balloc_desc = {
 1370         41,
 1371         "vop_balloc",
 1372         0,
 1373         vop_balloc_vp_offsets,
 1374         VDESC_NO_OFFSET,
 1375         VOPARG_OFFSETOF(struct vop_balloc_args, a_cred),
 1376         VDESC_NO_OFFSET,
 1377         VDESC_NO_OFFSET,
 1378         NULL,
 1379 };
 1380 #ifdef VNODE_OP_NOINLINE
 1381 int
 1382 VOP_BALLOC(vp, startoffset, size, cred, flags, bpp)
 1383         struct vnode *vp;
 1384         off_t startoffset;
 1385         int size;
 1386         struct ucred *cred;
 1387         int flags;
 1388         struct buf **bpp;
 1389 {
 1390         struct vop_balloc_args a;
 1391         a.a_desc = VDESC(vop_balloc);
 1392         a.a_vp = vp;
 1393         a.a_startoffset = startoffset;
 1394         a.a_size = size;
 1395         a.a_cred = cred;
 1396         a.a_flags = flags;
 1397         a.a_bpp = bpp;
 1398         return (VCALL(vp, VOFFSET(vop_balloc), &a));
 1399 }
 1400 #endif
 1401 
 1402 const int vop_reallocblks_vp_offsets[] = {
 1403         VOPARG_OFFSETOF(struct vop_reallocblks_args,a_vp),
 1404         VDESC_NO_OFFSET
 1405 };
 1406 const struct vnodeop_desc vop_reallocblks_desc = {
 1407         42,
 1408         "vop_reallocblks",
 1409         0,
 1410         vop_reallocblks_vp_offsets,
 1411         VDESC_NO_OFFSET,
 1412         VDESC_NO_OFFSET,
 1413         VDESC_NO_OFFSET,
 1414         VDESC_NO_OFFSET,
 1415         NULL,
 1416 };
 1417 #ifdef VNODE_OP_NOINLINE
 1418 int
 1419 VOP_REALLOCBLKS(vp, buflist)
 1420         struct vnode *vp;
 1421         struct cluster_save *buflist;
 1422 {
 1423         struct vop_reallocblks_args a;
 1424         a.a_desc = VDESC(vop_reallocblks);
 1425         a.a_vp = vp;
 1426         a.a_buflist = buflist;
 1427         return (VCALL(vp, VOFFSET(vop_reallocblks), &a));
 1428 }
 1429 #endif
 1430 
 1431 const int vop_vfree_vp_offsets[] = {
 1432         VOPARG_OFFSETOF(struct vop_vfree_args,a_pvp),
 1433         VDESC_NO_OFFSET
 1434 };
 1435 const struct vnodeop_desc vop_vfree_desc = {
 1436         43,
 1437         "vop_vfree",
 1438         0,
 1439         vop_vfree_vp_offsets,
 1440         VDESC_NO_OFFSET,
 1441         VDESC_NO_OFFSET,
 1442         VDESC_NO_OFFSET,
 1443         VDESC_NO_OFFSET,
 1444         NULL,
 1445 };
 1446 #ifdef VNODE_OP_NOINLINE
 1447 int
 1448 VOP_VFREE(pvp, ino, mode)
 1449         struct vnode *pvp;
 1450         ino_t ino;
 1451         int mode;
 1452 {
 1453         struct vop_vfree_args a;
 1454         a.a_desc = VDESC(vop_vfree);
 1455         a.a_pvp = pvp;
 1456         a.a_ino = ino;
 1457         a.a_mode = mode;
 1458         return (VCALL(pvp, VOFFSET(vop_vfree), &a));
 1459 }
 1460 #endif
 1461 
 1462 const int vop_truncate_vp_offsets[] = {
 1463         VOPARG_OFFSETOF(struct vop_truncate_args,a_vp),
 1464         VDESC_NO_OFFSET
 1465 };
 1466 const struct vnodeop_desc vop_truncate_desc = {
 1467         44,
 1468         "vop_truncate",
 1469         0,
 1470         vop_truncate_vp_offsets,
 1471         VDESC_NO_OFFSET,
 1472         VOPARG_OFFSETOF(struct vop_truncate_args, a_cred),
 1473         VOPARG_OFFSETOF(struct vop_truncate_args, a_p),
 1474         VDESC_NO_OFFSET,
 1475         NULL,
 1476 };
 1477 #ifdef VNODE_OP_NOINLINE
 1478 int
 1479 VOP_TRUNCATE(vp, length, flags, cred, p)
 1480         struct vnode *vp;
 1481         off_t length;
 1482         int flags;
 1483         struct ucred *cred;
 1484         struct proc *p;
 1485 {
 1486         struct vop_truncate_args a;
 1487         a.a_desc = VDESC(vop_truncate);
 1488         a.a_vp = vp;
 1489         a.a_length = length;
 1490         a.a_flags = flags;
 1491         a.a_cred = cred;
 1492         a.a_p = p;
 1493         return (VCALL(vp, VOFFSET(vop_truncate), &a));
 1494 }
 1495 #endif
 1496 
 1497 const int vop_update_vp_offsets[] = {
 1498         VOPARG_OFFSETOF(struct vop_update_args,a_vp),
 1499         VDESC_NO_OFFSET
 1500 };
 1501 const struct vnodeop_desc vop_update_desc = {
 1502         45,
 1503         "vop_update",
 1504         0,
 1505         vop_update_vp_offsets,
 1506         VDESC_NO_OFFSET,
 1507         VDESC_NO_OFFSET,
 1508         VDESC_NO_OFFSET,
 1509         VDESC_NO_OFFSET,
 1510         NULL,
 1511 };
 1512 #ifdef VNODE_OP_NOINLINE
 1513 int
 1514 VOP_UPDATE(vp, access, modify, flags)
 1515         struct vnode *vp;
 1516         struct timespec *access;
 1517         struct timespec *modify;
 1518         int flags;
 1519 {
 1520         struct vop_update_args a;
 1521         a.a_desc = VDESC(vop_update);
 1522         a.a_vp = vp;
 1523         a.a_access = access;
 1524         a.a_modify = modify;
 1525         a.a_flags = flags;
 1526         return (VCALL(vp, VOFFSET(vop_update), &a));
 1527 }
 1528 #endif
 1529 
 1530 const int vop_lease_vp_offsets[] = {
 1531         VOPARG_OFFSETOF(struct vop_lease_args,a_vp),
 1532         VDESC_NO_OFFSET
 1533 };
 1534 const struct vnodeop_desc vop_lease_desc = {
 1535         46,
 1536         "vop_lease",
 1537         0,
 1538         vop_lease_vp_offsets,
 1539         VDESC_NO_OFFSET,
 1540         VOPARG_OFFSETOF(struct vop_lease_args, a_cred),
 1541         VOPARG_OFFSETOF(struct vop_lease_args, a_p),
 1542         VDESC_NO_OFFSET,
 1543         NULL,
 1544 };
 1545 #ifdef VNODE_OP_NOINLINE
 1546 int
 1547 VOP_LEASE(vp, p, cred, flag)
 1548         struct vnode *vp;
 1549         struct proc *p;
 1550         struct ucred *cred;
 1551         int flag;
 1552 {
 1553         struct vop_lease_args a;
 1554         a.a_desc = VDESC(vop_lease);
 1555         a.a_vp = vp;
 1556         a.a_p = p;
 1557         a.a_cred = cred;
 1558         a.a_flag = flag;
 1559         return (VCALL(vp, VOFFSET(vop_lease), &a));
 1560 }
 1561 #endif
 1562 
 1563 const int vop_whiteout_vp_offsets[] = {
 1564         VOPARG_OFFSETOF(struct vop_whiteout_args,a_dvp),
 1565         VDESC_NO_OFFSET
 1566 };
 1567 const struct vnodeop_desc vop_whiteout_desc = {
 1568         47,
 1569         "vop_whiteout",
 1570         0,
 1571         vop_whiteout_vp_offsets,
 1572         VDESC_NO_OFFSET,
 1573         VDESC_NO_OFFSET,
 1574         VDESC_NO_OFFSET,
 1575         VOPARG_OFFSETOF(struct vop_whiteout_args, a_cnp),
 1576         NULL,
 1577 };
 1578 #ifdef VNODE_OP_NOINLINE
 1579 int
 1580 VOP_WHITEOUT(dvp, cnp, flags)
 1581         struct vnode *dvp;
 1582         struct componentname *cnp;
 1583         int flags;
 1584 {
 1585         struct vop_whiteout_args a;
 1586         a.a_desc = VDESC(vop_whiteout);
 1587         a.a_dvp = dvp;
 1588         a.a_cnp = cnp;
 1589         a.a_flags = flags;
 1590         return (VCALL(dvp, VOFFSET(vop_whiteout), &a));
 1591 }
 1592 #endif
 1593 
 1594 const int vop_getpages_vp_offsets[] = {
 1595         VOPARG_OFFSETOF(struct vop_getpages_args,a_vp),
 1596         VDESC_NO_OFFSET
 1597 };
 1598 const struct vnodeop_desc vop_getpages_desc = {
 1599         48,
 1600         "vop_getpages",
 1601         0,
 1602         vop_getpages_vp_offsets,
 1603         VDESC_NO_OFFSET,
 1604         VDESC_NO_OFFSET,
 1605         VDESC_NO_OFFSET,
 1606         VDESC_NO_OFFSET,
 1607         NULL,
 1608 };
 1609 #ifdef VNODE_OP_NOINLINE
 1610 int
 1611 VOP_GETPAGES(vp, offset, m, count, centeridx, access_type, advice, flags)
 1612         struct vnode *vp;
 1613         voff_t offset;
 1614         struct vm_page **m;
 1615         int *count;
 1616         int centeridx;
 1617         vm_prot_t access_type;
 1618         int advice;
 1619         int flags;
 1620 {
 1621         struct vop_getpages_args a;
 1622         a.a_desc = VDESC(vop_getpages);
 1623         a.a_vp = vp;
 1624         a.a_offset = offset;
 1625         a.a_m = m;
 1626         a.a_count = count;
 1627         a.a_centeridx = centeridx;
 1628         a.a_access_type = access_type;
 1629         a.a_advice = advice;
 1630         a.a_flags = flags;
 1631         return (VCALL(vp, VOFFSET(vop_getpages), &a));
 1632 }
 1633 #endif
 1634 
 1635 const int vop_putpages_vp_offsets[] = {
 1636         VOPARG_OFFSETOF(struct vop_putpages_args,a_vp),
 1637         VDESC_NO_OFFSET
 1638 };
 1639 const struct vnodeop_desc vop_putpages_desc = {
 1640         49,
 1641         "vop_putpages",
 1642         0,
 1643         vop_putpages_vp_offsets,
 1644         VDESC_NO_OFFSET,
 1645         VDESC_NO_OFFSET,
 1646         VDESC_NO_OFFSET,
 1647         VDESC_NO_OFFSET,
 1648         NULL,
 1649 };
 1650 #ifdef VNODE_OP_NOINLINE
 1651 int
 1652 VOP_PUTPAGES(vp, offlo, offhi, flags)
 1653         struct vnode *vp;
 1654         voff_t offlo;
 1655         voff_t offhi;
 1656         int flags;
 1657 {
 1658         struct vop_putpages_args a;
 1659         a.a_desc = VDESC(vop_putpages);
 1660         a.a_vp = vp;
 1661         a.a_offlo = offlo;
 1662         a.a_offhi = offhi;
 1663         a.a_flags = flags;
 1664         return (VCALL(vp, VOFFSET(vop_putpages), &a));
 1665 }
 1666 #endif
 1667 
 1668 /* End of special cases. */
 1669 
 1670 const struct vnodeop_desc * const vfs_op_descs[] = {
 1671         &vop_default_desc,      /* MUST BE FIRST */
 1672         &vop_bwrite_desc,       /* XXX: SPECIAL CASE */
 1673 
 1674         &vop_lookup_desc,
 1675         &vop_create_desc,
 1676         &vop_mknod_desc,
 1677         &vop_open_desc,
 1678         &vop_close_desc,
 1679         &vop_access_desc,
 1680         &vop_getattr_desc,
 1681         &vop_setattr_desc,
 1682         &vop_read_desc,
 1683         &vop_write_desc,
 1684         &vop_ioctl_desc,
 1685         &vop_fcntl_desc,
 1686         &vop_poll_desc,
 1687         &vop_kqfilter_desc,
 1688         &vop_revoke_desc,
 1689         &vop_mmap_desc,
 1690         &vop_fsync_desc,
 1691         &vop_seek_desc,
 1692         &vop_remove_desc,
 1693         &vop_link_desc,
 1694         &vop_rename_desc,
 1695         &vop_mkdir_desc,
 1696         &vop_rmdir_desc,
 1697         &vop_symlink_desc,
 1698         &vop_readdir_desc,
 1699         &vop_readlink_desc,
 1700         &vop_abortop_desc,
 1701         &vop_inactive_desc,
 1702         &vop_reclaim_desc,
 1703         &vop_lock_desc,
 1704         &vop_unlock_desc,
 1705         &vop_bmap_desc,
 1706         &vop_strategy_desc,
 1707         &vop_print_desc,
 1708         &vop_islocked_desc,
 1709         &vop_pathconf_desc,
 1710         &vop_advlock_desc,
 1711         &vop_blkatoff_desc,
 1712         &vop_valloc_desc,
 1713         &vop_balloc_desc,
 1714         &vop_reallocblks_desc,
 1715         &vop_vfree_desc,
 1716         &vop_truncate_desc,
 1717         &vop_update_desc,
 1718         &vop_lease_desc,
 1719         &vop_whiteout_desc,
 1720         &vop_getpages_desc,
 1721         &vop_putpages_desc,
 1722         NULL
 1723 };
 1724 

Cache object: e4ef28ffdcf0d556409b042b6cd40325


[ 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.