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-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 /*      $NetBSD: vnode_if.c,v 1.53 2005/02/26 22:15:10 perry Exp $      */
    2 
    3 /*
    4  * Warning: DO NOT EDIT! This file is automatically generated!
    5  * (Modifications made here may easily be lost!)
    6  *
    7  * Created from the file:
    8  *      NetBSD: vnode_if.src,v 1.44 2005/02/26 22:14:39 perry Exp
    9  * by the script:
   10  *      NetBSD: vnode_if.sh,v 1.38 2005/02/26 22:06:38 perry 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.53 2005/02/26 22:15:10 perry 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 #include "opt_vnode_lockdebug.h"
   56 
   57 #include <sys/param.h>
   58 #include <sys/mount.h>
   59 #include <sys/buf.h>
   60 #include <sys/vnode.h>
   61 
   62 const struct vnodeop_desc vop_default_desc = {
   63         0,
   64         "default",
   65         0,
   66         NULL,
   67         VDESC_NO_OFFSET,
   68         VDESC_NO_OFFSET,
   69         VDESC_NO_OFFSET,
   70         VDESC_NO_OFFSET,
   71         NULL,
   72 };
   73 
   74 
   75 /* Special cases: */
   76 
   77 const int vop_bwrite_vp_offsets[] = {
   78         VDESC_NO_OFFSET
   79 };
   80 const struct vnodeop_desc vop_bwrite_desc = {
   81         1,
   82         "vop_bwrite",
   83         0,
   84         vop_bwrite_vp_offsets,
   85         VDESC_NO_OFFSET,
   86         VDESC_NO_OFFSET,
   87         VDESC_NO_OFFSET,
   88         VDESC_NO_OFFSET,
   89         NULL,
   90 };
   91 #ifdef VNODE_OP_NOINLINE
   92 int
   93 VOP_BWRITE(bp)
   94         struct buf *bp;
   95 {
   96         struct vop_bwrite_args a;
   97 #ifdef VNODE_LOCKDEBUG
   98 #endif
   99         a.a_desc = VDESC(vop_bwrite);
  100         a.a_bp = bp;
  101         return (VCALL(bp->b_vp, VOFFSET(vop_bwrite), &a));
  102 }
  103 #endif
  104 
  105 /* End of special cases */
  106 
  107 const int vop_lookup_vp_offsets[] = {
  108         VOPARG_OFFSETOF(struct vop_lookup_args,a_dvp),
  109         VDESC_NO_OFFSET
  110 };
  111 const struct vnodeop_desc vop_lookup_desc = {
  112         2,
  113         "vop_lookup",
  114         0,
  115         vop_lookup_vp_offsets,
  116         VOPARG_OFFSETOF(struct vop_lookup_args, a_vpp),
  117         VDESC_NO_OFFSET,
  118         VDESC_NO_OFFSET,
  119         VOPARG_OFFSETOF(struct vop_lookup_args, a_cnp),
  120         NULL,
  121 };
  122 #ifdef VNODE_OP_NOINLINE
  123 int
  124 VOP_LOOKUP(dvp, vpp, cnp)
  125         struct vnode *dvp;
  126         struct vnode **vpp;
  127         struct componentname *cnp;
  128 {
  129         struct vop_lookup_args a;
  130 #ifdef VNODE_LOCKDEBUG
  131 #endif
  132         a.a_desc = VDESC(vop_lookup);
  133         a.a_dvp = dvp;
  134         a.a_vpp = vpp;
  135         a.a_cnp = cnp;
  136         return (VCALL(dvp, VOFFSET(vop_lookup), &a));
  137 }
  138 #endif
  139 
  140 const int vop_create_vp_offsets[] = {
  141         VOPARG_OFFSETOF(struct vop_create_args,a_dvp),
  142         VDESC_NO_OFFSET
  143 };
  144 const struct vnodeop_desc vop_create_desc = {
  145         3,
  146         "vop_create",
  147         0 | VDESC_VP0_WILLPUT,
  148         vop_create_vp_offsets,
  149         VOPARG_OFFSETOF(struct vop_create_args, a_vpp),
  150         VDESC_NO_OFFSET,
  151         VDESC_NO_OFFSET,
  152         VOPARG_OFFSETOF(struct vop_create_args, a_cnp),
  153         NULL,
  154 };
  155 #ifdef VNODE_OP_NOINLINE
  156 int
  157 VOP_CREATE(dvp, vpp, cnp, vap)
  158         struct vnode *dvp;
  159         struct vnode **vpp;
  160         struct componentname *cnp;
  161         struct vattr *vap;
  162 {
  163         struct vop_create_args a;
  164 #ifdef VNODE_LOCKDEBUG
  165         int islocked_dvp;
  166 #endif
  167         a.a_desc = VDESC(vop_create);
  168         a.a_dvp = dvp;
  169 #ifdef VNODE_LOCKDEBUG
  170         islocked_dvp = (dvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1;
  171         if (islocked_dvp != 1)
  172                 panic("vop_create: dvp: locked %d, expected %d", islocked_dvp, 1);
  173 #endif
  174         a.a_vpp = vpp;
  175         a.a_cnp = cnp;
  176         a.a_vap = vap;
  177         return (VCALL(dvp, VOFFSET(vop_create), &a));
  178 }
  179 #endif
  180 
  181 const int vop_mknod_vp_offsets[] = {
  182         VOPARG_OFFSETOF(struct vop_mknod_args,a_dvp),
  183         VDESC_NO_OFFSET
  184 };
  185 const struct vnodeop_desc vop_mknod_desc = {
  186         4,
  187         "vop_mknod",
  188         0 | VDESC_VP0_WILLPUT,
  189         vop_mknod_vp_offsets,
  190         VOPARG_OFFSETOF(struct vop_mknod_args, a_vpp),
  191         VDESC_NO_OFFSET,
  192         VDESC_NO_OFFSET,
  193         VOPARG_OFFSETOF(struct vop_mknod_args, a_cnp),
  194         NULL,
  195 };
  196 #ifdef VNODE_OP_NOINLINE
  197 int
  198 VOP_MKNOD(dvp, vpp, cnp, vap)
  199         struct vnode *dvp;
  200         struct vnode **vpp;
  201         struct componentname *cnp;
  202         struct vattr *vap;
  203 {
  204         struct vop_mknod_args a;
  205 #ifdef VNODE_LOCKDEBUG
  206         int islocked_dvp;
  207 #endif
  208         a.a_desc = VDESC(vop_mknod);
  209         a.a_dvp = dvp;
  210 #ifdef VNODE_LOCKDEBUG
  211         islocked_dvp = (dvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1;
  212         if (islocked_dvp != 1)
  213                 panic("vop_mknod: dvp: locked %d, expected %d", islocked_dvp, 1);
  214 #endif
  215         a.a_vpp = vpp;
  216         a.a_cnp = cnp;
  217         a.a_vap = vap;
  218         return (VCALL(dvp, VOFFSET(vop_mknod), &a));
  219 }
  220 #endif
  221 
  222 const int vop_open_vp_offsets[] = {
  223         VOPARG_OFFSETOF(struct vop_open_args,a_vp),
  224         VDESC_NO_OFFSET
  225 };
  226 const struct vnodeop_desc vop_open_desc = {
  227         5,
  228         "vop_open",
  229         0,
  230         vop_open_vp_offsets,
  231         VDESC_NO_OFFSET,
  232         VOPARG_OFFSETOF(struct vop_open_args, a_cred),
  233         VOPARG_OFFSETOF(struct vop_open_args, a_p),
  234         VDESC_NO_OFFSET,
  235         NULL,
  236 };
  237 #ifdef VNODE_OP_NOINLINE
  238 int
  239 VOP_OPEN(vp, mode, cred, p)
  240         struct vnode *vp;
  241         int mode;
  242         struct ucred *cred;
  243         struct proc *p;
  244 {
  245         struct vop_open_args a;
  246 #ifdef VNODE_LOCKDEBUG
  247         int islocked_vp;
  248 #endif
  249         a.a_desc = VDESC(vop_open);
  250         a.a_vp = vp;
  251 #ifdef VNODE_LOCKDEBUG
  252         islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
  253         if (islocked_vp != 1)
  254                 panic("vop_open: vp: locked %d, expected %d", islocked_vp, 1);
  255 #endif
  256         a.a_mode = mode;
  257         a.a_cred = cred;
  258         a.a_p = p;
  259         return (VCALL(vp, VOFFSET(vop_open), &a));
  260 }
  261 #endif
  262 
  263 const int vop_close_vp_offsets[] = {
  264         VOPARG_OFFSETOF(struct vop_close_args,a_vp),
  265         VDESC_NO_OFFSET
  266 };
  267 const struct vnodeop_desc vop_close_desc = {
  268         6,
  269         "vop_close",
  270         0,
  271         vop_close_vp_offsets,
  272         VDESC_NO_OFFSET,
  273         VOPARG_OFFSETOF(struct vop_close_args, a_cred),
  274         VOPARG_OFFSETOF(struct vop_close_args, a_p),
  275         VDESC_NO_OFFSET,
  276         NULL,
  277 };
  278 #ifdef VNODE_OP_NOINLINE
  279 int
  280 VOP_CLOSE(vp, fflag, cred, p)
  281         struct vnode *vp;
  282         int fflag;
  283         struct ucred *cred;
  284         struct proc *p;
  285 {
  286         struct vop_close_args a;
  287 #ifdef VNODE_LOCKDEBUG
  288         int islocked_vp;
  289 #endif
  290         a.a_desc = VDESC(vop_close);
  291         a.a_vp = vp;
  292 #ifdef VNODE_LOCKDEBUG
  293         islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
  294         if (islocked_vp != 1)
  295                 panic("vop_close: vp: locked %d, expected %d", islocked_vp, 1);
  296 #endif
  297         a.a_fflag = fflag;
  298         a.a_cred = cred;
  299         a.a_p = p;
  300         return (VCALL(vp, VOFFSET(vop_close), &a));
  301 }
  302 #endif
  303 
  304 const int vop_access_vp_offsets[] = {
  305         VOPARG_OFFSETOF(struct vop_access_args,a_vp),
  306         VDESC_NO_OFFSET
  307 };
  308 const struct vnodeop_desc vop_access_desc = {
  309         7,
  310         "vop_access",
  311         0,
  312         vop_access_vp_offsets,
  313         VDESC_NO_OFFSET,
  314         VOPARG_OFFSETOF(struct vop_access_args, a_cred),
  315         VOPARG_OFFSETOF(struct vop_access_args, a_p),
  316         VDESC_NO_OFFSET,
  317         NULL,
  318 };
  319 #ifdef VNODE_OP_NOINLINE
  320 int
  321 VOP_ACCESS(vp, mode, cred, p)
  322         struct vnode *vp;
  323         int mode;
  324         struct ucred *cred;
  325         struct proc *p;
  326 {
  327         struct vop_access_args a;
  328 #ifdef VNODE_LOCKDEBUG
  329         int islocked_vp;
  330 #endif
  331         a.a_desc = VDESC(vop_access);
  332         a.a_vp = vp;
  333 #ifdef VNODE_LOCKDEBUG
  334         islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
  335         if (islocked_vp != 1)
  336                 panic("vop_access: vp: locked %d, expected %d", islocked_vp, 1);
  337 #endif
  338         a.a_mode = mode;
  339         a.a_cred = cred;
  340         a.a_p = p;
  341         return (VCALL(vp, VOFFSET(vop_access), &a));
  342 }
  343 #endif
  344 
  345 const int vop_getattr_vp_offsets[] = {
  346         VOPARG_OFFSETOF(struct vop_getattr_args,a_vp),
  347         VDESC_NO_OFFSET
  348 };
  349 const struct vnodeop_desc vop_getattr_desc = {
  350         8,
  351         "vop_getattr",
  352         0,
  353         vop_getattr_vp_offsets,
  354         VDESC_NO_OFFSET,
  355         VOPARG_OFFSETOF(struct vop_getattr_args, a_cred),
  356         VOPARG_OFFSETOF(struct vop_getattr_args, a_p),
  357         VDESC_NO_OFFSET,
  358         NULL,
  359 };
  360 #ifdef VNODE_OP_NOINLINE
  361 int
  362 VOP_GETATTR(vp, vap, cred, p)
  363         struct vnode *vp;
  364         struct vattr *vap;
  365         struct ucred *cred;
  366         struct proc *p;
  367 {
  368         struct vop_getattr_args a;
  369 #ifdef VNODE_LOCKDEBUG
  370 #endif
  371         a.a_desc = VDESC(vop_getattr);
  372         a.a_vp = vp;
  373         a.a_vap = vap;
  374         a.a_cred = cred;
  375         a.a_p = p;
  376         return (VCALL(vp, VOFFSET(vop_getattr), &a));
  377 }
  378 #endif
  379 
  380 const int vop_setattr_vp_offsets[] = {
  381         VOPARG_OFFSETOF(struct vop_setattr_args,a_vp),
  382         VDESC_NO_OFFSET
  383 };
  384 const struct vnodeop_desc vop_setattr_desc = {
  385         9,
  386         "vop_setattr",
  387         0,
  388         vop_setattr_vp_offsets,
  389         VDESC_NO_OFFSET,
  390         VOPARG_OFFSETOF(struct vop_setattr_args, a_cred),
  391         VOPARG_OFFSETOF(struct vop_setattr_args, a_p),
  392         VDESC_NO_OFFSET,
  393         NULL,
  394 };
  395 #ifdef VNODE_OP_NOINLINE
  396 int
  397 VOP_SETATTR(vp, vap, cred, p)
  398         struct vnode *vp;
  399         struct vattr *vap;
  400         struct ucred *cred;
  401         struct proc *p;
  402 {
  403         struct vop_setattr_args a;
  404 #ifdef VNODE_LOCKDEBUG
  405         int islocked_vp;
  406 #endif
  407         a.a_desc = VDESC(vop_setattr);
  408         a.a_vp = vp;
  409 #ifdef VNODE_LOCKDEBUG
  410         islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
  411         if (islocked_vp != 1)
  412                 panic("vop_setattr: vp: locked %d, expected %d", islocked_vp, 1);
  413 #endif
  414         a.a_vap = vap;
  415         a.a_cred = cred;
  416         a.a_p = p;
  417         return (VCALL(vp, VOFFSET(vop_setattr), &a));
  418 }
  419 #endif
  420 
  421 const int vop_read_vp_offsets[] = {
  422         VOPARG_OFFSETOF(struct vop_read_args,a_vp),
  423         VDESC_NO_OFFSET
  424 };
  425 const struct vnodeop_desc vop_read_desc = {
  426         10,
  427         "vop_read",
  428         0,
  429         vop_read_vp_offsets,
  430         VDESC_NO_OFFSET,
  431         VOPARG_OFFSETOF(struct vop_read_args, a_cred),
  432         VDESC_NO_OFFSET,
  433         VDESC_NO_OFFSET,
  434         NULL,
  435 };
  436 #ifdef VNODE_OP_NOINLINE
  437 int
  438 VOP_READ(vp, uio, ioflag, cred)
  439         struct vnode *vp;
  440         struct uio *uio;
  441         int ioflag;
  442         struct ucred *cred;
  443 {
  444         struct vop_read_args a;
  445 #ifdef VNODE_LOCKDEBUG
  446         int islocked_vp;
  447 #endif
  448         a.a_desc = VDESC(vop_read);
  449         a.a_vp = vp;
  450 #ifdef VNODE_LOCKDEBUG
  451         islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
  452         if (islocked_vp != 1)
  453                 panic("vop_read: vp: locked %d, expected %d", islocked_vp, 1);
  454 #endif
  455         a.a_uio = uio;
  456         a.a_ioflag = ioflag;
  457         a.a_cred = cred;
  458         return (VCALL(vp, VOFFSET(vop_read), &a));
  459 }
  460 #endif
  461 
  462 const int vop_write_vp_offsets[] = {
  463         VOPARG_OFFSETOF(struct vop_write_args,a_vp),
  464         VDESC_NO_OFFSET
  465 };
  466 const struct vnodeop_desc vop_write_desc = {
  467         11,
  468         "vop_write",
  469         0,
  470         vop_write_vp_offsets,
  471         VDESC_NO_OFFSET,
  472         VOPARG_OFFSETOF(struct vop_write_args, a_cred),
  473         VDESC_NO_OFFSET,
  474         VDESC_NO_OFFSET,
  475         NULL,
  476 };
  477 #ifdef VNODE_OP_NOINLINE
  478 int
  479 VOP_WRITE(vp, uio, ioflag, cred)
  480         struct vnode *vp;
  481         struct uio *uio;
  482         int ioflag;
  483         struct ucred *cred;
  484 {
  485         struct vop_write_args a;
  486 #ifdef VNODE_LOCKDEBUG
  487         int islocked_vp;
  488 #endif
  489         a.a_desc = VDESC(vop_write);
  490         a.a_vp = vp;
  491 #ifdef VNODE_LOCKDEBUG
  492         islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
  493         if (islocked_vp != 1)
  494                 panic("vop_write: vp: locked %d, expected %d", islocked_vp, 1);
  495 #endif
  496         a.a_uio = uio;
  497         a.a_ioflag = ioflag;
  498         a.a_cred = cred;
  499         return (VCALL(vp, VOFFSET(vop_write), &a));
  500 }
  501 #endif
  502 
  503 const int vop_ioctl_vp_offsets[] = {
  504         VOPARG_OFFSETOF(struct vop_ioctl_args,a_vp),
  505         VDESC_NO_OFFSET
  506 };
  507 const struct vnodeop_desc vop_ioctl_desc = {
  508         12,
  509         "vop_ioctl",
  510         0,
  511         vop_ioctl_vp_offsets,
  512         VDESC_NO_OFFSET,
  513         VOPARG_OFFSETOF(struct vop_ioctl_args, a_cred),
  514         VOPARG_OFFSETOF(struct vop_ioctl_args, a_p),
  515         VDESC_NO_OFFSET,
  516         NULL,
  517 };
  518 #ifdef VNODE_OP_NOINLINE
  519 int
  520 VOP_IOCTL(vp, command, data, fflag, cred, p)
  521         struct vnode *vp;
  522         u_long command;
  523         void *data;
  524         int fflag;
  525         struct ucred *cred;
  526         struct proc *p;
  527 {
  528         struct vop_ioctl_args a;
  529 #ifdef VNODE_LOCKDEBUG
  530         int islocked_vp;
  531 #endif
  532         a.a_desc = VDESC(vop_ioctl);
  533         a.a_vp = vp;
  534 #ifdef VNODE_LOCKDEBUG
  535         islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0;
  536         if (islocked_vp != 0)
  537                 panic("vop_ioctl: vp: locked %d, expected %d", islocked_vp, 0);
  538 #endif
  539         a.a_command = command;
  540         a.a_data = data;
  541         a.a_fflag = fflag;
  542         a.a_cred = cred;
  543         a.a_p = p;
  544         return (VCALL(vp, VOFFSET(vop_ioctl), &a));
  545 }
  546 #endif
  547 
  548 const int vop_fcntl_vp_offsets[] = {
  549         VOPARG_OFFSETOF(struct vop_fcntl_args,a_vp),
  550         VDESC_NO_OFFSET
  551 };
  552 const struct vnodeop_desc vop_fcntl_desc = {
  553         13,
  554         "vop_fcntl",
  555         0,
  556         vop_fcntl_vp_offsets,
  557         VDESC_NO_OFFSET,
  558         VOPARG_OFFSETOF(struct vop_fcntl_args, a_cred),
  559         VOPARG_OFFSETOF(struct vop_fcntl_args, a_p),
  560         VDESC_NO_OFFSET,
  561         NULL,
  562 };
  563 #ifdef VNODE_OP_NOINLINE
  564 int
  565 VOP_FCNTL(vp, command, data, fflag, cred, p)
  566         struct vnode *vp;
  567         u_int command;
  568         void *data;
  569         int fflag;
  570         struct ucred *cred;
  571         struct proc *p;
  572 {
  573         struct vop_fcntl_args a;
  574 #ifdef VNODE_LOCKDEBUG
  575         int islocked_vp;
  576 #endif
  577         a.a_desc = VDESC(vop_fcntl);
  578         a.a_vp = vp;
  579 #ifdef VNODE_LOCKDEBUG
  580         islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
  581         if (islocked_vp != 1)
  582                 panic("vop_fcntl: vp: locked %d, expected %d", islocked_vp, 1);
  583 #endif
  584         a.a_command = command;
  585         a.a_data = data;
  586         a.a_fflag = fflag;
  587         a.a_cred = cred;
  588         a.a_p = p;
  589         return (VCALL(vp, VOFFSET(vop_fcntl), &a));
  590 }
  591 #endif
  592 
  593 const int vop_poll_vp_offsets[] = {
  594         VOPARG_OFFSETOF(struct vop_poll_args,a_vp),
  595         VDESC_NO_OFFSET
  596 };
  597 const struct vnodeop_desc vop_poll_desc = {
  598         14,
  599         "vop_poll",
  600         0,
  601         vop_poll_vp_offsets,
  602         VDESC_NO_OFFSET,
  603         VDESC_NO_OFFSET,
  604         VOPARG_OFFSETOF(struct vop_poll_args, a_p),
  605         VDESC_NO_OFFSET,
  606         NULL,
  607 };
  608 #ifdef VNODE_OP_NOINLINE
  609 int
  610 VOP_POLL(vp, events, p)
  611         struct vnode *vp;
  612         int events;
  613         struct proc *p;
  614 {
  615         struct vop_poll_args a;
  616 #ifdef VNODE_LOCKDEBUG
  617         int islocked_vp;
  618 #endif
  619         a.a_desc = VDESC(vop_poll);
  620         a.a_vp = vp;
  621 #ifdef VNODE_LOCKDEBUG
  622         islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0;
  623         if (islocked_vp != 0)
  624                 panic("vop_poll: vp: locked %d, expected %d", islocked_vp, 0);
  625 #endif
  626         a.a_events = events;
  627         a.a_p = p;
  628         return (VCALL(vp, VOFFSET(vop_poll), &a));
  629 }
  630 #endif
  631 
  632 const int vop_kqfilter_vp_offsets[] = {
  633         VOPARG_OFFSETOF(struct vop_kqfilter_args,a_vp),
  634         VDESC_NO_OFFSET
  635 };
  636 const struct vnodeop_desc vop_kqfilter_desc = {
  637         15,
  638         "vop_kqfilter",
  639         0,
  640         vop_kqfilter_vp_offsets,
  641         VDESC_NO_OFFSET,
  642         VDESC_NO_OFFSET,
  643         VDESC_NO_OFFSET,
  644         VDESC_NO_OFFSET,
  645         NULL,
  646 };
  647 #ifdef VNODE_OP_NOINLINE
  648 int
  649 VOP_KQFILTER(vp, kn)
  650         struct vnode *vp;
  651         struct knote *kn;
  652 {
  653         struct vop_kqfilter_args a;
  654 #ifdef VNODE_LOCKDEBUG
  655         int islocked_vp;
  656 #endif
  657         a.a_desc = VDESC(vop_kqfilter);
  658         a.a_vp = vp;
  659 #ifdef VNODE_LOCKDEBUG
  660         islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0;
  661         if (islocked_vp != 0)
  662                 panic("vop_kqfilter: vp: locked %d, expected %d", islocked_vp, 0);
  663 #endif
  664         a.a_kn = kn;
  665         return (VCALL(vp, VOFFSET(vop_kqfilter), &a));
  666 }
  667 #endif
  668 
  669 const int vop_revoke_vp_offsets[] = {
  670         VOPARG_OFFSETOF(struct vop_revoke_args,a_vp),
  671         VDESC_NO_OFFSET
  672 };
  673 const struct vnodeop_desc vop_revoke_desc = {
  674         16,
  675         "vop_revoke",
  676         0,
  677         vop_revoke_vp_offsets,
  678         VDESC_NO_OFFSET,
  679         VDESC_NO_OFFSET,
  680         VDESC_NO_OFFSET,
  681         VDESC_NO_OFFSET,
  682         NULL,
  683 };
  684 #ifdef VNODE_OP_NOINLINE
  685 int
  686 VOP_REVOKE(vp, flags)
  687         struct vnode *vp;
  688         int flags;
  689 {
  690         struct vop_revoke_args a;
  691 #ifdef VNODE_LOCKDEBUG
  692         int islocked_vp;
  693 #endif
  694         a.a_desc = VDESC(vop_revoke);
  695         a.a_vp = vp;
  696 #ifdef VNODE_LOCKDEBUG
  697         islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0;
  698         if (islocked_vp != 0)
  699                 panic("vop_revoke: vp: locked %d, expected %d", islocked_vp, 0);
  700 #endif
  701         a.a_flags = flags;
  702         return (VCALL(vp, VOFFSET(vop_revoke), &a));
  703 }
  704 #endif
  705 
  706 const int vop_mmap_vp_offsets[] = {
  707         VOPARG_OFFSETOF(struct vop_mmap_args,a_vp),
  708         VDESC_NO_OFFSET
  709 };
  710 const struct vnodeop_desc vop_mmap_desc = {
  711         17,
  712         "vop_mmap",
  713         0,
  714         vop_mmap_vp_offsets,
  715         VDESC_NO_OFFSET,
  716         VOPARG_OFFSETOF(struct vop_mmap_args, a_cred),
  717         VOPARG_OFFSETOF(struct vop_mmap_args, a_p),
  718         VDESC_NO_OFFSET,
  719         NULL,
  720 };
  721 #ifdef VNODE_OP_NOINLINE
  722 int
  723 VOP_MMAP(vp, fflags, cred, p)
  724         struct vnode *vp;
  725         int fflags;
  726         struct ucred *cred;
  727         struct proc *p;
  728 {
  729         struct vop_mmap_args a;
  730 #ifdef VNODE_LOCKDEBUG
  731 #endif
  732         a.a_desc = VDESC(vop_mmap);
  733         a.a_vp = vp;
  734         a.a_fflags = fflags;
  735         a.a_cred = cred;
  736         a.a_p = p;
  737         return (VCALL(vp, VOFFSET(vop_mmap), &a));
  738 }
  739 #endif
  740 
  741 const int vop_fsync_vp_offsets[] = {
  742         VOPARG_OFFSETOF(struct vop_fsync_args,a_vp),
  743         VDESC_NO_OFFSET
  744 };
  745 const struct vnodeop_desc vop_fsync_desc = {
  746         18,
  747         "vop_fsync",
  748         0,
  749         vop_fsync_vp_offsets,
  750         VDESC_NO_OFFSET,
  751         VOPARG_OFFSETOF(struct vop_fsync_args, a_cred),
  752         VOPARG_OFFSETOF(struct vop_fsync_args, a_p),
  753         VDESC_NO_OFFSET,
  754         NULL,
  755 };
  756 #ifdef VNODE_OP_NOINLINE
  757 int
  758 VOP_FSYNC(vp, cred, flags, offlo, offhi, p)
  759         struct vnode *vp;
  760         struct ucred *cred;
  761         int flags;
  762         off_t offlo;
  763         off_t offhi;
  764         struct proc *p;
  765 {
  766         struct vop_fsync_args a;
  767 #ifdef VNODE_LOCKDEBUG
  768         int islocked_vp;
  769 #endif
  770         a.a_desc = VDESC(vop_fsync);
  771         a.a_vp = vp;
  772 #ifdef VNODE_LOCKDEBUG
  773         islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
  774         if (islocked_vp != 1)
  775                 panic("vop_fsync: vp: locked %d, expected %d", islocked_vp, 1);
  776 #endif
  777         a.a_cred = cred;
  778         a.a_flags = flags;
  779         a.a_offlo = offlo;
  780         a.a_offhi = offhi;
  781         a.a_p = p;
  782         return (VCALL(vp, VOFFSET(vop_fsync), &a));
  783 }
  784 #endif
  785 
  786 const int vop_seek_vp_offsets[] = {
  787         VOPARG_OFFSETOF(struct vop_seek_args,a_vp),
  788         VDESC_NO_OFFSET
  789 };
  790 const struct vnodeop_desc vop_seek_desc = {
  791         19,
  792         "vop_seek",
  793         0,
  794         vop_seek_vp_offsets,
  795         VDESC_NO_OFFSET,
  796         VOPARG_OFFSETOF(struct vop_seek_args, a_cred),
  797         VDESC_NO_OFFSET,
  798         VDESC_NO_OFFSET,
  799         NULL,
  800 };
  801 #ifdef VNODE_OP_NOINLINE
  802 int
  803 VOP_SEEK(vp, oldoff, newoff, cred)
  804         struct vnode *vp;
  805         off_t oldoff;
  806         off_t newoff;
  807         struct ucred *cred;
  808 {
  809         struct vop_seek_args a;
  810 #ifdef VNODE_LOCKDEBUG
  811 #endif
  812         a.a_desc = VDESC(vop_seek);
  813         a.a_vp = vp;
  814         a.a_oldoff = oldoff;
  815         a.a_newoff = newoff;
  816         a.a_cred = cred;
  817         return (VCALL(vp, VOFFSET(vop_seek), &a));
  818 }
  819 #endif
  820 
  821 const int vop_remove_vp_offsets[] = {
  822         VOPARG_OFFSETOF(struct vop_remove_args,a_dvp),
  823         VOPARG_OFFSETOF(struct vop_remove_args,a_vp),
  824         VDESC_NO_OFFSET
  825 };
  826 const struct vnodeop_desc vop_remove_desc = {
  827         20,
  828         "vop_remove",
  829         0 | VDESC_VP0_WILLPUT | VDESC_VP1_WILLPUT,
  830         vop_remove_vp_offsets,
  831         VDESC_NO_OFFSET,
  832         VDESC_NO_OFFSET,
  833         VDESC_NO_OFFSET,
  834         VOPARG_OFFSETOF(struct vop_remove_args, a_cnp),
  835         NULL,
  836 };
  837 #ifdef VNODE_OP_NOINLINE
  838 int
  839 VOP_REMOVE(dvp, vp, cnp)
  840         struct vnode *dvp;
  841         struct vnode *vp;
  842         struct componentname *cnp;
  843 {
  844         struct vop_remove_args a;
  845 #ifdef VNODE_LOCKDEBUG
  846         int islocked_dvp;
  847         int islocked_vp;
  848 #endif
  849         a.a_desc = VDESC(vop_remove);
  850         a.a_dvp = dvp;
  851 #ifdef VNODE_LOCKDEBUG
  852         islocked_dvp = (dvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1;
  853         if (islocked_dvp != 1)
  854                 panic("vop_remove: dvp: locked %d, expected %d", islocked_dvp, 1);
  855 #endif
  856         a.a_vp = vp;
  857 #ifdef VNODE_LOCKDEBUG
  858         islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
  859         if (islocked_vp != 1)
  860                 panic("vop_remove: vp: locked %d, expected %d", islocked_vp, 1);
  861 #endif
  862         a.a_cnp = cnp;
  863         return (VCALL(dvp, VOFFSET(vop_remove), &a));
  864 }
  865 #endif
  866 
  867 const int vop_link_vp_offsets[] = {
  868         VOPARG_OFFSETOF(struct vop_link_args,a_dvp),
  869         VOPARG_OFFSETOF(struct vop_link_args,a_vp),
  870         VDESC_NO_OFFSET
  871 };
  872 const struct vnodeop_desc vop_link_desc = {
  873         21,
  874         "vop_link",
  875         0 | VDESC_VP0_WILLPUT,
  876         vop_link_vp_offsets,
  877         VDESC_NO_OFFSET,
  878         VDESC_NO_OFFSET,
  879         VDESC_NO_OFFSET,
  880         VOPARG_OFFSETOF(struct vop_link_args, a_cnp),
  881         NULL,
  882 };
  883 #ifdef VNODE_OP_NOINLINE
  884 int
  885 VOP_LINK(dvp, vp, cnp)
  886         struct vnode *dvp;
  887         struct vnode *vp;
  888         struct componentname *cnp;
  889 {
  890         struct vop_link_args a;
  891 #ifdef VNODE_LOCKDEBUG
  892         int islocked_dvp;
  893         int islocked_vp;
  894 #endif
  895         a.a_desc = VDESC(vop_link);
  896         a.a_dvp = dvp;
  897 #ifdef VNODE_LOCKDEBUG
  898         islocked_dvp = (dvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1;
  899         if (islocked_dvp != 1)
  900                 panic("vop_link: dvp: locked %d, expected %d", islocked_dvp, 1);
  901 #endif
  902         a.a_vp = vp;
  903 #ifdef VNODE_LOCKDEBUG
  904         islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0;
  905         if (islocked_vp != 0)
  906                 panic("vop_link: vp: locked %d, expected %d", islocked_vp, 0);
  907 #endif
  908         a.a_cnp = cnp;
  909         return (VCALL(dvp, VOFFSET(vop_link), &a));
  910 }
  911 #endif
  912 
  913 const int vop_rename_vp_offsets[] = {
  914         VOPARG_OFFSETOF(struct vop_rename_args,a_fdvp),
  915         VOPARG_OFFSETOF(struct vop_rename_args,a_fvp),
  916         VOPARG_OFFSETOF(struct vop_rename_args,a_tdvp),
  917         VOPARG_OFFSETOF(struct vop_rename_args,a_tvp),
  918         VDESC_NO_OFFSET
  919 };
  920 const struct vnodeop_desc vop_rename_desc = {
  921         22,
  922         "vop_rename",
  923         0 | VDESC_VP0_WILLRELE | VDESC_VP1_WILLRELE | VDESC_VP2_WILLPUT | VDESC_VP3_WILLPUT,
  924         vop_rename_vp_offsets,
  925         VDESC_NO_OFFSET,
  926         VDESC_NO_OFFSET,
  927         VDESC_NO_OFFSET,
  928         VOPARG_OFFSETOF(struct vop_rename_args, a_fcnp),
  929         NULL,
  930 };
  931 #ifdef VNODE_OP_NOINLINE
  932 int
  933 VOP_RENAME(fdvp, fvp, fcnp, tdvp, tvp, tcnp)
  934         struct vnode *fdvp;
  935         struct vnode *fvp;
  936         struct componentname *fcnp;
  937         struct vnode *tdvp;
  938         struct vnode *tvp;
  939         struct componentname *tcnp;
  940 {
  941         struct vop_rename_args a;
  942 #ifdef VNODE_LOCKDEBUG
  943         int islocked_fdvp;
  944         int islocked_fvp;
  945         int islocked_tdvp;
  946 #endif
  947         a.a_desc = VDESC(vop_rename);
  948         a.a_fdvp = fdvp;
  949 #ifdef VNODE_LOCKDEBUG
  950         islocked_fdvp = (fdvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(fdvp) == LK_EXCLUSIVE) : 0;
  951         if (islocked_fdvp != 0)
  952                 panic("vop_rename: fdvp: locked %d, expected %d", islocked_fdvp, 0);
  953 #endif
  954         a.a_fvp = fvp;
  955 #ifdef VNODE_LOCKDEBUG
  956         islocked_fvp = (fvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(fvp) == LK_EXCLUSIVE) : 0;
  957         if (islocked_fvp != 0)
  958                 panic("vop_rename: fvp: locked %d, expected %d", islocked_fvp, 0);
  959 #endif
  960         a.a_fcnp = fcnp;
  961         a.a_tdvp = tdvp;
  962 #ifdef VNODE_LOCKDEBUG
  963         islocked_tdvp = (tdvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(tdvp) == LK_EXCLUSIVE) : 1;
  964         if (islocked_tdvp != 1)
  965                 panic("vop_rename: tdvp: locked %d, expected %d", islocked_tdvp, 1);
  966 #endif
  967         a.a_tvp = tvp;
  968         a.a_tcnp = tcnp;
  969         return (VCALL(fdvp, VOFFSET(vop_rename), &a));
  970 }
  971 #endif
  972 
  973 const int vop_mkdir_vp_offsets[] = {
  974         VOPARG_OFFSETOF(struct vop_mkdir_args,a_dvp),
  975         VDESC_NO_OFFSET
  976 };
  977 const struct vnodeop_desc vop_mkdir_desc = {
  978         23,
  979         "vop_mkdir",
  980         0 | VDESC_VP0_WILLPUT,
  981         vop_mkdir_vp_offsets,
  982         VOPARG_OFFSETOF(struct vop_mkdir_args, a_vpp),
  983         VDESC_NO_OFFSET,
  984         VDESC_NO_OFFSET,
  985         VOPARG_OFFSETOF(struct vop_mkdir_args, a_cnp),
  986         NULL,
  987 };
  988 #ifdef VNODE_OP_NOINLINE
  989 int
  990 VOP_MKDIR(dvp, vpp, cnp, vap)
  991         struct vnode *dvp;
  992         struct vnode **vpp;
  993         struct componentname *cnp;
  994         struct vattr *vap;
  995 {
  996         struct vop_mkdir_args a;
  997 #ifdef VNODE_LOCKDEBUG
  998         int islocked_dvp;
  999 #endif
 1000         a.a_desc = VDESC(vop_mkdir);
 1001         a.a_dvp = dvp;
 1002 #ifdef VNODE_LOCKDEBUG
 1003         islocked_dvp = (dvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1;
 1004         if (islocked_dvp != 1)
 1005                 panic("vop_mkdir: dvp: locked %d, expected %d", islocked_dvp, 1);
 1006 #endif
 1007         a.a_vpp = vpp;
 1008         a.a_cnp = cnp;
 1009         a.a_vap = vap;
 1010         return (VCALL(dvp, VOFFSET(vop_mkdir), &a));
 1011 }
 1012 #endif
 1013 
 1014 const int vop_rmdir_vp_offsets[] = {
 1015         VOPARG_OFFSETOF(struct vop_rmdir_args,a_dvp),
 1016         VOPARG_OFFSETOF(struct vop_rmdir_args,a_vp),
 1017         VDESC_NO_OFFSET
 1018 };
 1019 const struct vnodeop_desc vop_rmdir_desc = {
 1020         24,
 1021         "vop_rmdir",
 1022         0 | VDESC_VP0_WILLPUT | VDESC_VP1_WILLPUT,
 1023         vop_rmdir_vp_offsets,
 1024         VDESC_NO_OFFSET,
 1025         VDESC_NO_OFFSET,
 1026         VDESC_NO_OFFSET,
 1027         VOPARG_OFFSETOF(struct vop_rmdir_args, a_cnp),
 1028         NULL,
 1029 };
 1030 #ifdef VNODE_OP_NOINLINE
 1031 int
 1032 VOP_RMDIR(dvp, vp, cnp)
 1033         struct vnode *dvp;
 1034         struct vnode *vp;
 1035         struct componentname *cnp;
 1036 {
 1037         struct vop_rmdir_args a;
 1038 #ifdef VNODE_LOCKDEBUG
 1039         int islocked_dvp;
 1040         int islocked_vp;
 1041 #endif
 1042         a.a_desc = VDESC(vop_rmdir);
 1043         a.a_dvp = dvp;
 1044 #ifdef VNODE_LOCKDEBUG
 1045         islocked_dvp = (dvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1;
 1046         if (islocked_dvp != 1)
 1047                 panic("vop_rmdir: dvp: locked %d, expected %d", islocked_dvp, 1);
 1048 #endif
 1049         a.a_vp = vp;
 1050 #ifdef VNODE_LOCKDEBUG
 1051         islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 1052         if (islocked_vp != 1)
 1053                 panic("vop_rmdir: vp: locked %d, expected %d", islocked_vp, 1);
 1054 #endif
 1055         a.a_cnp = cnp;
 1056         return (VCALL(dvp, VOFFSET(vop_rmdir), &a));
 1057 }
 1058 #endif
 1059 
 1060 const int vop_symlink_vp_offsets[] = {
 1061         VOPARG_OFFSETOF(struct vop_symlink_args,a_dvp),
 1062         VDESC_NO_OFFSET
 1063 };
 1064 const struct vnodeop_desc vop_symlink_desc = {
 1065         25,
 1066         "vop_symlink",
 1067         0 | VDESC_VP0_WILLPUT,
 1068         vop_symlink_vp_offsets,
 1069         VOPARG_OFFSETOF(struct vop_symlink_args, a_vpp),
 1070         VDESC_NO_OFFSET,
 1071         VDESC_NO_OFFSET,
 1072         VOPARG_OFFSETOF(struct vop_symlink_args, a_cnp),
 1073         NULL,
 1074 };
 1075 #ifdef VNODE_OP_NOINLINE
 1076 int
 1077 VOP_SYMLINK(dvp, vpp, cnp, vap, target)
 1078         struct vnode *dvp;
 1079         struct vnode **vpp;
 1080         struct componentname *cnp;
 1081         struct vattr *vap;
 1082         char *target;
 1083 {
 1084         struct vop_symlink_args a;
 1085 #ifdef VNODE_LOCKDEBUG
 1086         int islocked_dvp;
 1087 #endif
 1088         a.a_desc = VDESC(vop_symlink);
 1089         a.a_dvp = dvp;
 1090 #ifdef VNODE_LOCKDEBUG
 1091         islocked_dvp = (dvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1;
 1092         if (islocked_dvp != 1)
 1093                 panic("vop_symlink: dvp: locked %d, expected %d", islocked_dvp, 1);
 1094 #endif
 1095         a.a_vpp = vpp;
 1096         a.a_cnp = cnp;
 1097         a.a_vap = vap;
 1098         a.a_target = target;
 1099         return (VCALL(dvp, VOFFSET(vop_symlink), &a));
 1100 }
 1101 #endif
 1102 
 1103 const int vop_readdir_vp_offsets[] = {
 1104         VOPARG_OFFSETOF(struct vop_readdir_args,a_vp),
 1105         VDESC_NO_OFFSET
 1106 };
 1107 const struct vnodeop_desc vop_readdir_desc = {
 1108         26,
 1109         "vop_readdir",
 1110         0,
 1111         vop_readdir_vp_offsets,
 1112         VDESC_NO_OFFSET,
 1113         VOPARG_OFFSETOF(struct vop_readdir_args, a_cred),
 1114         VDESC_NO_OFFSET,
 1115         VDESC_NO_OFFSET,
 1116         NULL,
 1117 };
 1118 #ifdef VNODE_OP_NOINLINE
 1119 int
 1120 VOP_READDIR(vp, uio, cred, eofflag, cookies, ncookies)
 1121         struct vnode *vp;
 1122         struct uio *uio;
 1123         struct ucred *cred;
 1124         int *eofflag;
 1125         off_t **cookies;
 1126         int *ncookies;
 1127 {
 1128         struct vop_readdir_args a;
 1129 #ifdef VNODE_LOCKDEBUG
 1130         int islocked_vp;
 1131 #endif
 1132         a.a_desc = VDESC(vop_readdir);
 1133         a.a_vp = vp;
 1134 #ifdef VNODE_LOCKDEBUG
 1135         islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 1136         if (islocked_vp != 1)
 1137                 panic("vop_readdir: vp: locked %d, expected %d", islocked_vp, 1);
 1138 #endif
 1139         a.a_uio = uio;
 1140         a.a_cred = cred;
 1141         a.a_eofflag = eofflag;
 1142         a.a_cookies = cookies;
 1143         a.a_ncookies = ncookies;
 1144         return (VCALL(vp, VOFFSET(vop_readdir), &a));
 1145 }
 1146 #endif
 1147 
 1148 const int vop_readlink_vp_offsets[] = {
 1149         VOPARG_OFFSETOF(struct vop_readlink_args,a_vp),
 1150         VDESC_NO_OFFSET
 1151 };
 1152 const struct vnodeop_desc vop_readlink_desc = {
 1153         27,
 1154         "vop_readlink",
 1155         0,
 1156         vop_readlink_vp_offsets,
 1157         VDESC_NO_OFFSET,
 1158         VOPARG_OFFSETOF(struct vop_readlink_args, a_cred),
 1159         VDESC_NO_OFFSET,
 1160         VDESC_NO_OFFSET,
 1161         NULL,
 1162 };
 1163 #ifdef VNODE_OP_NOINLINE
 1164 int
 1165 VOP_READLINK(vp, uio, cred)
 1166         struct vnode *vp;
 1167         struct uio *uio;
 1168         struct ucred *cred;
 1169 {
 1170         struct vop_readlink_args a;
 1171 #ifdef VNODE_LOCKDEBUG
 1172         int islocked_vp;
 1173 #endif
 1174         a.a_desc = VDESC(vop_readlink);
 1175         a.a_vp = vp;
 1176 #ifdef VNODE_LOCKDEBUG
 1177         islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 1178         if (islocked_vp != 1)
 1179                 panic("vop_readlink: vp: locked %d, expected %d", islocked_vp, 1);
 1180 #endif
 1181         a.a_uio = uio;
 1182         a.a_cred = cred;
 1183         return (VCALL(vp, VOFFSET(vop_readlink), &a));
 1184 }
 1185 #endif
 1186 
 1187 const int vop_abortop_vp_offsets[] = {
 1188         VOPARG_OFFSETOF(struct vop_abortop_args,a_dvp),
 1189         VDESC_NO_OFFSET
 1190 };
 1191 const struct vnodeop_desc vop_abortop_desc = {
 1192         28,
 1193         "vop_abortop",
 1194         0,
 1195         vop_abortop_vp_offsets,
 1196         VDESC_NO_OFFSET,
 1197         VDESC_NO_OFFSET,
 1198         VDESC_NO_OFFSET,
 1199         VOPARG_OFFSETOF(struct vop_abortop_args, a_cnp),
 1200         NULL,
 1201 };
 1202 #ifdef VNODE_OP_NOINLINE
 1203 int
 1204 VOP_ABORTOP(dvp, cnp)
 1205         struct vnode *dvp;
 1206         struct componentname *cnp;
 1207 {
 1208         struct vop_abortop_args a;
 1209 #ifdef VNODE_LOCKDEBUG
 1210 #endif
 1211         a.a_desc = VDESC(vop_abortop);
 1212         a.a_dvp = dvp;
 1213         a.a_cnp = cnp;
 1214         return (VCALL(dvp, VOFFSET(vop_abortop), &a));
 1215 }
 1216 #endif
 1217 
 1218 const int vop_inactive_vp_offsets[] = {
 1219         VOPARG_OFFSETOF(struct vop_inactive_args,a_vp),
 1220         VDESC_NO_OFFSET
 1221 };
 1222 const struct vnodeop_desc vop_inactive_desc = {
 1223         29,
 1224         "vop_inactive",
 1225         0 | VDESC_VP0_WILLUNLOCK,
 1226         vop_inactive_vp_offsets,
 1227         VDESC_NO_OFFSET,
 1228         VDESC_NO_OFFSET,
 1229         VOPARG_OFFSETOF(struct vop_inactive_args, a_p),
 1230         VDESC_NO_OFFSET,
 1231         NULL,
 1232 };
 1233 #ifdef VNODE_OP_NOINLINE
 1234 int
 1235 VOP_INACTIVE(vp, p)
 1236         struct vnode *vp;
 1237         struct proc *p;
 1238 {
 1239         struct vop_inactive_args a;
 1240 #ifdef VNODE_LOCKDEBUG
 1241         int islocked_vp;
 1242 #endif
 1243         a.a_desc = VDESC(vop_inactive);
 1244         a.a_vp = vp;
 1245 #ifdef VNODE_LOCKDEBUG
 1246         islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 1247         if (islocked_vp != 1)
 1248                 panic("vop_inactive: vp: locked %d, expected %d", islocked_vp, 1);
 1249 #endif
 1250         a.a_p = p;
 1251         return (VCALL(vp, VOFFSET(vop_inactive), &a));
 1252 }
 1253 #endif
 1254 
 1255 const int vop_reclaim_vp_offsets[] = {
 1256         VOPARG_OFFSETOF(struct vop_reclaim_args,a_vp),
 1257         VDESC_NO_OFFSET
 1258 };
 1259 const struct vnodeop_desc vop_reclaim_desc = {
 1260         30,
 1261         "vop_reclaim",
 1262         0,
 1263         vop_reclaim_vp_offsets,
 1264         VDESC_NO_OFFSET,
 1265         VDESC_NO_OFFSET,
 1266         VOPARG_OFFSETOF(struct vop_reclaim_args, a_p),
 1267         VDESC_NO_OFFSET,
 1268         NULL,
 1269 };
 1270 #ifdef VNODE_OP_NOINLINE
 1271 int
 1272 VOP_RECLAIM(vp, p)
 1273         struct vnode *vp;
 1274         struct proc *p;
 1275 {
 1276         struct vop_reclaim_args a;
 1277 #ifdef VNODE_LOCKDEBUG
 1278         int islocked_vp;
 1279 #endif
 1280         a.a_desc = VDESC(vop_reclaim);
 1281         a.a_vp = vp;
 1282 #ifdef VNODE_LOCKDEBUG
 1283         islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0;
 1284         if (islocked_vp != 0)
 1285                 panic("vop_reclaim: vp: locked %d, expected %d", islocked_vp, 0);
 1286 #endif
 1287         a.a_p = p;
 1288         return (VCALL(vp, VOFFSET(vop_reclaim), &a));
 1289 }
 1290 #endif
 1291 
 1292 const int vop_lock_vp_offsets[] = {
 1293         VOPARG_OFFSETOF(struct vop_lock_args,a_vp),
 1294         VDESC_NO_OFFSET
 1295 };
 1296 const struct vnodeop_desc vop_lock_desc = {
 1297         31,
 1298         "vop_lock",
 1299         0,
 1300         vop_lock_vp_offsets,
 1301         VDESC_NO_OFFSET,
 1302         VDESC_NO_OFFSET,
 1303         VDESC_NO_OFFSET,
 1304         VDESC_NO_OFFSET,
 1305         NULL,
 1306 };
 1307 #ifdef VNODE_OP_NOINLINE
 1308 int
 1309 VOP_LOCK(vp, flags)
 1310         struct vnode *vp;
 1311         int flags;
 1312 {
 1313         struct vop_lock_args a;
 1314 #ifdef VNODE_LOCKDEBUG
 1315         int islocked_vp;
 1316 #endif
 1317         a.a_desc = VDESC(vop_lock);
 1318         a.a_vp = vp;
 1319 #ifdef VNODE_LOCKDEBUG
 1320         islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0;
 1321         if (islocked_vp != 0)
 1322                 panic("vop_lock: vp: locked %d, expected %d", islocked_vp, 0);
 1323 #endif
 1324         a.a_flags = flags;
 1325         return (VCALL(vp, VOFFSET(vop_lock), &a));
 1326 }
 1327 #endif
 1328 
 1329 const int vop_unlock_vp_offsets[] = {
 1330         VOPARG_OFFSETOF(struct vop_unlock_args,a_vp),
 1331         VDESC_NO_OFFSET
 1332 };
 1333 const struct vnodeop_desc vop_unlock_desc = {
 1334         32,
 1335         "vop_unlock",
 1336         0,
 1337         vop_unlock_vp_offsets,
 1338         VDESC_NO_OFFSET,
 1339         VDESC_NO_OFFSET,
 1340         VDESC_NO_OFFSET,
 1341         VDESC_NO_OFFSET,
 1342         NULL,
 1343 };
 1344 #ifdef VNODE_OP_NOINLINE
 1345 int
 1346 VOP_UNLOCK(vp, flags)
 1347         struct vnode *vp;
 1348         int flags;
 1349 {
 1350         struct vop_unlock_args a;
 1351 #ifdef VNODE_LOCKDEBUG
 1352         int islocked_vp;
 1353 #endif
 1354         a.a_desc = VDESC(vop_unlock);
 1355         a.a_vp = vp;
 1356 #ifdef VNODE_LOCKDEBUG
 1357         islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 1358         if (islocked_vp != 1)
 1359                 panic("vop_unlock: vp: locked %d, expected %d", islocked_vp, 1);
 1360 #endif
 1361         a.a_flags = flags;
 1362         return (VCALL(vp, VOFFSET(vop_unlock), &a));
 1363 }
 1364 #endif
 1365 
 1366 const int vop_bmap_vp_offsets[] = {
 1367         VOPARG_OFFSETOF(struct vop_bmap_args,a_vp),
 1368         VDESC_NO_OFFSET
 1369 };
 1370 const struct vnodeop_desc vop_bmap_desc = {
 1371         33,
 1372         "vop_bmap",
 1373         0,
 1374         vop_bmap_vp_offsets,
 1375         VOPARG_OFFSETOF(struct vop_bmap_args, a_vpp),
 1376         VDESC_NO_OFFSET,
 1377         VDESC_NO_OFFSET,
 1378         VDESC_NO_OFFSET,
 1379         NULL,
 1380 };
 1381 #ifdef VNODE_OP_NOINLINE
 1382 int
 1383 VOP_BMAP(vp, bn, vpp, bnp, runp)
 1384         struct vnode *vp;
 1385         daddr_t bn;
 1386         struct vnode **vpp;
 1387         daddr_t *bnp;
 1388         int *runp;
 1389 {
 1390         struct vop_bmap_args a;
 1391 #ifdef VNODE_LOCKDEBUG
 1392         int islocked_vp;
 1393 #endif
 1394         a.a_desc = VDESC(vop_bmap);
 1395         a.a_vp = vp;
 1396 #ifdef VNODE_LOCKDEBUG
 1397         islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 1398         if (islocked_vp != 1)
 1399                 panic("vop_bmap: vp: locked %d, expected %d", islocked_vp, 1);
 1400 #endif
 1401         a.a_bn = bn;
 1402         a.a_vpp = vpp;
 1403         a.a_bnp = bnp;
 1404         a.a_runp = runp;
 1405         return (VCALL(vp, VOFFSET(vop_bmap), &a));
 1406 }
 1407 #endif
 1408 
 1409 const int vop_strategy_vp_offsets[] = {
 1410         VOPARG_OFFSETOF(struct vop_strategy_args,a_vp),
 1411         VDESC_NO_OFFSET
 1412 };
 1413 const struct vnodeop_desc vop_strategy_desc = {
 1414         34,
 1415         "vop_strategy",
 1416         0,
 1417         vop_strategy_vp_offsets,
 1418         VDESC_NO_OFFSET,
 1419         VDESC_NO_OFFSET,
 1420         VDESC_NO_OFFSET,
 1421         VDESC_NO_OFFSET,
 1422         NULL,
 1423 };
 1424 #ifdef VNODE_OP_NOINLINE
 1425 int
 1426 VOP_STRATEGY(vp, bp)
 1427         struct vnode *vp;
 1428         struct buf *bp;
 1429 {
 1430         struct vop_strategy_args a;
 1431 #ifdef VNODE_LOCKDEBUG
 1432 #endif
 1433         a.a_desc = VDESC(vop_strategy);
 1434         a.a_vp = vp;
 1435         a.a_bp = bp;
 1436         return (VCALL(vp, VOFFSET(vop_strategy), &a));
 1437 }
 1438 #endif
 1439 
 1440 const int vop_print_vp_offsets[] = {
 1441         VOPARG_OFFSETOF(struct vop_print_args,a_vp),
 1442         VDESC_NO_OFFSET
 1443 };
 1444 const struct vnodeop_desc vop_print_desc = {
 1445         35,
 1446         "vop_print",
 1447         0,
 1448         vop_print_vp_offsets,
 1449         VDESC_NO_OFFSET,
 1450         VDESC_NO_OFFSET,
 1451         VDESC_NO_OFFSET,
 1452         VDESC_NO_OFFSET,
 1453         NULL,
 1454 };
 1455 #ifdef VNODE_OP_NOINLINE
 1456 int
 1457 VOP_PRINT(vp)
 1458         struct vnode *vp;
 1459 {
 1460         struct vop_print_args a;
 1461 #ifdef VNODE_LOCKDEBUG
 1462 #endif
 1463         a.a_desc = VDESC(vop_print);
 1464         a.a_vp = vp;
 1465         return (VCALL(vp, VOFFSET(vop_print), &a));
 1466 }
 1467 #endif
 1468 
 1469 const int vop_islocked_vp_offsets[] = {
 1470         VOPARG_OFFSETOF(struct vop_islocked_args,a_vp),
 1471         VDESC_NO_OFFSET
 1472 };
 1473 const struct vnodeop_desc vop_islocked_desc = {
 1474         36,
 1475         "vop_islocked",
 1476         0,
 1477         vop_islocked_vp_offsets,
 1478         VDESC_NO_OFFSET,
 1479         VDESC_NO_OFFSET,
 1480         VDESC_NO_OFFSET,
 1481         VDESC_NO_OFFSET,
 1482         NULL,
 1483 };
 1484 #ifdef VNODE_OP_NOINLINE
 1485 int
 1486 VOP_ISLOCKED(vp)
 1487         struct vnode *vp;
 1488 {
 1489         struct vop_islocked_args a;
 1490 #ifdef VNODE_LOCKDEBUG
 1491 #endif
 1492         a.a_desc = VDESC(vop_islocked);
 1493         a.a_vp = vp;
 1494         return (VCALL(vp, VOFFSET(vop_islocked), &a));
 1495 }
 1496 #endif
 1497 
 1498 const int vop_pathconf_vp_offsets[] = {
 1499         VOPARG_OFFSETOF(struct vop_pathconf_args,a_vp),
 1500         VDESC_NO_OFFSET
 1501 };
 1502 const struct vnodeop_desc vop_pathconf_desc = {
 1503         37,
 1504         "vop_pathconf",
 1505         0,
 1506         vop_pathconf_vp_offsets,
 1507         VDESC_NO_OFFSET,
 1508         VDESC_NO_OFFSET,
 1509         VDESC_NO_OFFSET,
 1510         VDESC_NO_OFFSET,
 1511         NULL,
 1512 };
 1513 #ifdef VNODE_OP_NOINLINE
 1514 int
 1515 VOP_PATHCONF(vp, name, retval)
 1516         struct vnode *vp;
 1517         int name;
 1518         register_t *retval;
 1519 {
 1520         struct vop_pathconf_args a;
 1521 #ifdef VNODE_LOCKDEBUG
 1522         int islocked_vp;
 1523 #endif
 1524         a.a_desc = VDESC(vop_pathconf);
 1525         a.a_vp = vp;
 1526 #ifdef VNODE_LOCKDEBUG
 1527         islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 1528         if (islocked_vp != 1)
 1529                 panic("vop_pathconf: vp: locked %d, expected %d", islocked_vp, 1);
 1530 #endif
 1531         a.a_name = name;
 1532         a.a_retval = retval;
 1533         return (VCALL(vp, VOFFSET(vop_pathconf), &a));
 1534 }
 1535 #endif
 1536 
 1537 const int vop_advlock_vp_offsets[] = {
 1538         VOPARG_OFFSETOF(struct vop_advlock_args,a_vp),
 1539         VDESC_NO_OFFSET
 1540 };
 1541 const struct vnodeop_desc vop_advlock_desc = {
 1542         38,
 1543         "vop_advlock",
 1544         0,
 1545         vop_advlock_vp_offsets,
 1546         VDESC_NO_OFFSET,
 1547         VDESC_NO_OFFSET,
 1548         VDESC_NO_OFFSET,
 1549         VDESC_NO_OFFSET,
 1550         NULL,
 1551 };
 1552 #ifdef VNODE_OP_NOINLINE
 1553 int
 1554 VOP_ADVLOCK(vp, id, op, fl, flags)
 1555         struct vnode *vp;
 1556         void *id;
 1557         int op;
 1558         struct flock *fl;
 1559         int flags;
 1560 {
 1561         struct vop_advlock_args a;
 1562 #ifdef VNODE_LOCKDEBUG
 1563         int islocked_vp;
 1564 #endif
 1565         a.a_desc = VDESC(vop_advlock);
 1566         a.a_vp = vp;
 1567 #ifdef VNODE_LOCKDEBUG
 1568         islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0;
 1569         if (islocked_vp != 0)
 1570                 panic("vop_advlock: vp: locked %d, expected %d", islocked_vp, 0);
 1571 #endif
 1572         a.a_id = id;
 1573         a.a_op = op;
 1574         a.a_fl = fl;
 1575         a.a_flags = flags;
 1576         return (VCALL(vp, VOFFSET(vop_advlock), &a));
 1577 }
 1578 #endif
 1579 
 1580 const int vop_blkatoff_vp_offsets[] = {
 1581         VOPARG_OFFSETOF(struct vop_blkatoff_args,a_vp),
 1582         VDESC_NO_OFFSET
 1583 };
 1584 const struct vnodeop_desc vop_blkatoff_desc = {
 1585         39,
 1586         "vop_blkatoff",
 1587         0,
 1588         vop_blkatoff_vp_offsets,
 1589         VDESC_NO_OFFSET,
 1590         VDESC_NO_OFFSET,
 1591         VDESC_NO_OFFSET,
 1592         VDESC_NO_OFFSET,
 1593         NULL,
 1594 };
 1595 #ifdef VNODE_OP_NOINLINE
 1596 int
 1597 VOP_BLKATOFF(vp, offset, res, bpp)
 1598         struct vnode *vp;
 1599         off_t offset;
 1600         char **res;
 1601         struct buf **bpp;
 1602 {
 1603         struct vop_blkatoff_args a;
 1604 #ifdef VNODE_LOCKDEBUG
 1605         int islocked_vp;
 1606 #endif
 1607         a.a_desc = VDESC(vop_blkatoff);
 1608         a.a_vp = vp;
 1609 #ifdef VNODE_LOCKDEBUG
 1610         islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 1611         if (islocked_vp != 1)
 1612                 panic("vop_blkatoff: vp: locked %d, expected %d", islocked_vp, 1);
 1613 #endif
 1614         a.a_offset = offset;
 1615         a.a_res = res;
 1616         a.a_bpp = bpp;
 1617         return (VCALL(vp, VOFFSET(vop_blkatoff), &a));
 1618 }
 1619 #endif
 1620 
 1621 const int vop_valloc_vp_offsets[] = {
 1622         VOPARG_OFFSETOF(struct vop_valloc_args,a_pvp),
 1623         VDESC_NO_OFFSET
 1624 };
 1625 const struct vnodeop_desc vop_valloc_desc = {
 1626         40,
 1627         "vop_valloc",
 1628         0,
 1629         vop_valloc_vp_offsets,
 1630         VOPARG_OFFSETOF(struct vop_valloc_args, a_vpp),
 1631         VOPARG_OFFSETOF(struct vop_valloc_args, a_cred),
 1632         VDESC_NO_OFFSET,
 1633         VDESC_NO_OFFSET,
 1634         NULL,
 1635 };
 1636 #ifdef VNODE_OP_NOINLINE
 1637 int
 1638 VOP_VALLOC(pvp, mode, cred, vpp)
 1639         struct vnode *pvp;
 1640         int mode;
 1641         struct ucred *cred;
 1642         struct vnode **vpp;
 1643 {
 1644         struct vop_valloc_args a;
 1645 #ifdef VNODE_LOCKDEBUG
 1646         int islocked_pvp;
 1647 #endif
 1648         a.a_desc = VDESC(vop_valloc);
 1649         a.a_pvp = pvp;
 1650 #ifdef VNODE_LOCKDEBUG
 1651         islocked_pvp = (pvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(pvp) == LK_EXCLUSIVE) : 1;
 1652         if (islocked_pvp != 1)
 1653                 panic("vop_valloc: pvp: locked %d, expected %d", islocked_pvp, 1);
 1654 #endif
 1655         a.a_mode = mode;
 1656         a.a_cred = cred;
 1657         a.a_vpp = vpp;
 1658         return (VCALL(pvp, VOFFSET(vop_valloc), &a));
 1659 }
 1660 #endif
 1661 
 1662 const int vop_balloc_vp_offsets[] = {
 1663         VOPARG_OFFSETOF(struct vop_balloc_args,a_vp),
 1664         VDESC_NO_OFFSET
 1665 };
 1666 const struct vnodeop_desc vop_balloc_desc = {
 1667         41,
 1668         "vop_balloc",
 1669         0,
 1670         vop_balloc_vp_offsets,
 1671         VDESC_NO_OFFSET,
 1672         VOPARG_OFFSETOF(struct vop_balloc_args, a_cred),
 1673         VDESC_NO_OFFSET,
 1674         VDESC_NO_OFFSET,
 1675         NULL,
 1676 };
 1677 #ifdef VNODE_OP_NOINLINE
 1678 int
 1679 VOP_BALLOC(vp, startoffset, size, cred, flags, bpp)
 1680         struct vnode *vp;
 1681         off_t startoffset;
 1682         int size;
 1683         struct ucred *cred;
 1684         int flags;
 1685         struct buf **bpp;
 1686 {
 1687         struct vop_balloc_args a;
 1688 #ifdef VNODE_LOCKDEBUG
 1689         int islocked_vp;
 1690 #endif
 1691         a.a_desc = VDESC(vop_balloc);
 1692         a.a_vp = vp;
 1693 #ifdef VNODE_LOCKDEBUG
 1694         islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 1695         if (islocked_vp != 1)
 1696                 panic("vop_balloc: vp: locked %d, expected %d", islocked_vp, 1);
 1697 #endif
 1698         a.a_startoffset = startoffset;
 1699         a.a_size = size;
 1700         a.a_cred = cred;
 1701         a.a_flags = flags;
 1702         a.a_bpp = bpp;
 1703         return (VCALL(vp, VOFFSET(vop_balloc), &a));
 1704 }
 1705 #endif
 1706 
 1707 const int vop_reallocblks_vp_offsets[] = {
 1708         VOPARG_OFFSETOF(struct vop_reallocblks_args,a_vp),
 1709         VDESC_NO_OFFSET
 1710 };
 1711 const struct vnodeop_desc vop_reallocblks_desc = {
 1712         42,
 1713         "vop_reallocblks",
 1714         0,
 1715         vop_reallocblks_vp_offsets,
 1716         VDESC_NO_OFFSET,
 1717         VDESC_NO_OFFSET,
 1718         VDESC_NO_OFFSET,
 1719         VDESC_NO_OFFSET,
 1720         NULL,
 1721 };
 1722 #ifdef VNODE_OP_NOINLINE
 1723 int
 1724 VOP_REALLOCBLKS(vp, buflist)
 1725         struct vnode *vp;
 1726         struct cluster_save *buflist;
 1727 {
 1728         struct vop_reallocblks_args a;
 1729 #ifdef VNODE_LOCKDEBUG
 1730         int islocked_vp;
 1731 #endif
 1732         a.a_desc = VDESC(vop_reallocblks);
 1733         a.a_vp = vp;
 1734 #ifdef VNODE_LOCKDEBUG
 1735         islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 1736         if (islocked_vp != 1)
 1737                 panic("vop_reallocblks: vp: locked %d, expected %d", islocked_vp, 1);
 1738 #endif
 1739         a.a_buflist = buflist;
 1740         return (VCALL(vp, VOFFSET(vop_reallocblks), &a));
 1741 }
 1742 #endif
 1743 
 1744 const int vop_vfree_vp_offsets[] = {
 1745         VOPARG_OFFSETOF(struct vop_vfree_args,a_pvp),
 1746         VDESC_NO_OFFSET
 1747 };
 1748 const struct vnodeop_desc vop_vfree_desc = {
 1749         43,
 1750         "vop_vfree",
 1751         0,
 1752         vop_vfree_vp_offsets,
 1753         VDESC_NO_OFFSET,
 1754         VDESC_NO_OFFSET,
 1755         VDESC_NO_OFFSET,
 1756         VDESC_NO_OFFSET,
 1757         NULL,
 1758 };
 1759 #ifdef VNODE_OP_NOINLINE
 1760 int
 1761 VOP_VFREE(pvp, ino, mode)
 1762         struct vnode *pvp;
 1763         ino_t ino;
 1764         int mode;
 1765 {
 1766         struct vop_vfree_args a;
 1767 #ifdef VNODE_LOCKDEBUG
 1768         int islocked_pvp;
 1769 #endif
 1770         a.a_desc = VDESC(vop_vfree);
 1771         a.a_pvp = pvp;
 1772 #ifdef VNODE_LOCKDEBUG
 1773         islocked_pvp = (pvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(pvp) == LK_EXCLUSIVE) : 1;
 1774         if (islocked_pvp != 1)
 1775                 panic("vop_vfree: pvp: locked %d, expected %d", islocked_pvp, 1);
 1776 #endif
 1777         a.a_ino = ino;
 1778         a.a_mode = mode;
 1779         return (VCALL(pvp, VOFFSET(vop_vfree), &a));
 1780 }
 1781 #endif
 1782 
 1783 const int vop_truncate_vp_offsets[] = {
 1784         VOPARG_OFFSETOF(struct vop_truncate_args,a_vp),
 1785         VDESC_NO_OFFSET
 1786 };
 1787 const struct vnodeop_desc vop_truncate_desc = {
 1788         44,
 1789         "vop_truncate",
 1790         0,
 1791         vop_truncate_vp_offsets,
 1792         VDESC_NO_OFFSET,
 1793         VOPARG_OFFSETOF(struct vop_truncate_args, a_cred),
 1794         VOPARG_OFFSETOF(struct vop_truncate_args, a_p),
 1795         VDESC_NO_OFFSET,
 1796         NULL,
 1797 };
 1798 #ifdef VNODE_OP_NOINLINE
 1799 int
 1800 VOP_TRUNCATE(vp, length, flags, cred, p)
 1801         struct vnode *vp;
 1802         off_t length;
 1803         int flags;
 1804         struct ucred *cred;
 1805         struct proc *p;
 1806 {
 1807         struct vop_truncate_args a;
 1808 #ifdef VNODE_LOCKDEBUG
 1809         int islocked_vp;
 1810 #endif
 1811         a.a_desc = VDESC(vop_truncate);
 1812         a.a_vp = vp;
 1813 #ifdef VNODE_LOCKDEBUG
 1814         islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 1815         if (islocked_vp != 1)
 1816                 panic("vop_truncate: vp: locked %d, expected %d", islocked_vp, 1);
 1817 #endif
 1818         a.a_length = length;
 1819         a.a_flags = flags;
 1820         a.a_cred = cred;
 1821         a.a_p = p;
 1822         return (VCALL(vp, VOFFSET(vop_truncate), &a));
 1823 }
 1824 #endif
 1825 
 1826 const int vop_update_vp_offsets[] = {
 1827         VOPARG_OFFSETOF(struct vop_update_args,a_vp),
 1828         VDESC_NO_OFFSET
 1829 };
 1830 const struct vnodeop_desc vop_update_desc = {
 1831         45,
 1832         "vop_update",
 1833         0,
 1834         vop_update_vp_offsets,
 1835         VDESC_NO_OFFSET,
 1836         VDESC_NO_OFFSET,
 1837         VDESC_NO_OFFSET,
 1838         VDESC_NO_OFFSET,
 1839         NULL,
 1840 };
 1841 #ifdef VNODE_OP_NOINLINE
 1842 int
 1843 VOP_UPDATE(vp, access, modify, flags)
 1844         struct vnode *vp;
 1845         struct timespec *access;
 1846         struct timespec *modify;
 1847         int flags;
 1848 {
 1849         struct vop_update_args a;
 1850 #ifdef VNODE_LOCKDEBUG
 1851         int islocked_vp;
 1852 #endif
 1853         a.a_desc = VDESC(vop_update);
 1854         a.a_vp = vp;
 1855 #ifdef VNODE_LOCKDEBUG
 1856         islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 1857         if (islocked_vp != 1)
 1858                 panic("vop_update: vp: locked %d, expected %d", islocked_vp, 1);
 1859 #endif
 1860         a.a_access = access;
 1861         a.a_modify = modify;
 1862         a.a_flags = flags;
 1863         return (VCALL(vp, VOFFSET(vop_update), &a));
 1864 }
 1865 #endif
 1866 
 1867 const int vop_lease_vp_offsets[] = {
 1868         VOPARG_OFFSETOF(struct vop_lease_args,a_vp),
 1869         VDESC_NO_OFFSET
 1870 };
 1871 const struct vnodeop_desc vop_lease_desc = {
 1872         46,
 1873         "vop_lease",
 1874         0,
 1875         vop_lease_vp_offsets,
 1876         VDESC_NO_OFFSET,
 1877         VOPARG_OFFSETOF(struct vop_lease_args, a_cred),
 1878         VOPARG_OFFSETOF(struct vop_lease_args, a_p),
 1879         VDESC_NO_OFFSET,
 1880         NULL,
 1881 };
 1882 #ifdef VNODE_OP_NOINLINE
 1883 int
 1884 VOP_LEASE(vp, p, cred, flag)
 1885         struct vnode *vp;
 1886         struct proc *p;
 1887         struct ucred *cred;
 1888         int flag;
 1889 {
 1890         struct vop_lease_args a;
 1891 #ifdef VNODE_LOCKDEBUG
 1892 #endif
 1893         a.a_desc = VDESC(vop_lease);
 1894         a.a_vp = vp;
 1895         a.a_p = p;
 1896         a.a_cred = cred;
 1897         a.a_flag = flag;
 1898         return (VCALL(vp, VOFFSET(vop_lease), &a));
 1899 }
 1900 #endif
 1901 
 1902 const int vop_whiteout_vp_offsets[] = {
 1903         VOPARG_OFFSETOF(struct vop_whiteout_args,a_dvp),
 1904         VDESC_NO_OFFSET
 1905 };
 1906 const struct vnodeop_desc vop_whiteout_desc = {
 1907         47,
 1908         "vop_whiteout",
 1909         0,
 1910         vop_whiteout_vp_offsets,
 1911         VDESC_NO_OFFSET,
 1912         VDESC_NO_OFFSET,
 1913         VDESC_NO_OFFSET,
 1914         VOPARG_OFFSETOF(struct vop_whiteout_args, a_cnp),
 1915         NULL,
 1916 };
 1917 #ifdef VNODE_OP_NOINLINE
 1918 int
 1919 VOP_WHITEOUT(dvp, cnp, flags)
 1920         struct vnode *dvp;
 1921         struct componentname *cnp;
 1922         int flags;
 1923 {
 1924         struct vop_whiteout_args a;
 1925 #ifdef VNODE_LOCKDEBUG
 1926         int islocked_dvp;
 1927 #endif
 1928         a.a_desc = VDESC(vop_whiteout);
 1929         a.a_dvp = dvp;
 1930 #ifdef VNODE_LOCKDEBUG
 1931         islocked_dvp = (dvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1;
 1932         if (islocked_dvp != 1)
 1933                 panic("vop_whiteout: dvp: locked %d, expected %d", islocked_dvp, 1);
 1934 #endif
 1935         a.a_cnp = cnp;
 1936         a.a_flags = flags;
 1937         return (VCALL(dvp, VOFFSET(vop_whiteout), &a));
 1938 }
 1939 #endif
 1940 
 1941 const int vop_getpages_vp_offsets[] = {
 1942         VOPARG_OFFSETOF(struct vop_getpages_args,a_vp),
 1943         VDESC_NO_OFFSET
 1944 };
 1945 const struct vnodeop_desc vop_getpages_desc = {
 1946         48,
 1947         "vop_getpages",
 1948         0,
 1949         vop_getpages_vp_offsets,
 1950         VDESC_NO_OFFSET,
 1951         VDESC_NO_OFFSET,
 1952         VDESC_NO_OFFSET,
 1953         VDESC_NO_OFFSET,
 1954         NULL,
 1955 };
 1956 #ifdef VNODE_OP_NOINLINE
 1957 int
 1958 VOP_GETPAGES(vp, offset, m, count, centeridx, access_type, advice, flags)
 1959         struct vnode *vp;
 1960         voff_t offset;
 1961         struct vm_page **m;
 1962         int *count;
 1963         int centeridx;
 1964         vm_prot_t access_type;
 1965         int advice;
 1966         int flags;
 1967 {
 1968         struct vop_getpages_args a;
 1969 #ifdef VNODE_LOCKDEBUG
 1970 #endif
 1971         a.a_desc = VDESC(vop_getpages);
 1972         a.a_vp = vp;
 1973         a.a_offset = offset;
 1974         a.a_m = m;
 1975         a.a_count = count;
 1976         a.a_centeridx = centeridx;
 1977         a.a_access_type = access_type;
 1978         a.a_advice = advice;
 1979         a.a_flags = flags;
 1980         return (VCALL(vp, VOFFSET(vop_getpages), &a));
 1981 }
 1982 #endif
 1983 
 1984 const int vop_putpages_vp_offsets[] = {
 1985         VOPARG_OFFSETOF(struct vop_putpages_args,a_vp),
 1986         VDESC_NO_OFFSET
 1987 };
 1988 const struct vnodeop_desc vop_putpages_desc = {
 1989         49,
 1990         "vop_putpages",
 1991         0,
 1992         vop_putpages_vp_offsets,
 1993         VDESC_NO_OFFSET,
 1994         VDESC_NO_OFFSET,
 1995         VDESC_NO_OFFSET,
 1996         VDESC_NO_OFFSET,
 1997         NULL,
 1998 };
 1999 #ifdef VNODE_OP_NOINLINE
 2000 int
 2001 VOP_PUTPAGES(vp, offlo, offhi, flags)
 2002         struct vnode *vp;
 2003         voff_t offlo;
 2004         voff_t offhi;
 2005         int flags;
 2006 {
 2007         struct vop_putpages_args a;
 2008 #ifdef VNODE_LOCKDEBUG
 2009 #endif
 2010         a.a_desc = VDESC(vop_putpages);
 2011         a.a_vp = vp;
 2012         a.a_offlo = offlo;
 2013         a.a_offhi = offhi;
 2014         a.a_flags = flags;
 2015         return (VCALL(vp, VOFFSET(vop_putpages), &a));
 2016 }
 2017 #endif
 2018 
 2019 const int vop_closeextattr_vp_offsets[] = {
 2020         VOPARG_OFFSETOF(struct vop_closeextattr_args,a_vp),
 2021         VDESC_NO_OFFSET
 2022 };
 2023 const struct vnodeop_desc vop_closeextattr_desc = {
 2024         50,
 2025         "vop_closeextattr",
 2026         0,
 2027         vop_closeextattr_vp_offsets,
 2028         VDESC_NO_OFFSET,
 2029         VOPARG_OFFSETOF(struct vop_closeextattr_args, a_cred),
 2030         VOPARG_OFFSETOF(struct vop_closeextattr_args, a_p),
 2031         VDESC_NO_OFFSET,
 2032         NULL,
 2033 };
 2034 #ifdef VNODE_OP_NOINLINE
 2035 int
 2036 VOP_CLOSEEXTATTR(vp, commit, cred, p)
 2037         struct vnode *vp;
 2038         int commit;
 2039         struct ucred *cred;
 2040         struct proc *p;
 2041 {
 2042         struct vop_closeextattr_args a;
 2043 #ifdef VNODE_LOCKDEBUG
 2044         int islocked_vp;
 2045 #endif
 2046         a.a_desc = VDESC(vop_closeextattr);
 2047         a.a_vp = vp;
 2048 #ifdef VNODE_LOCKDEBUG
 2049         islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 2050         if (islocked_vp != 1)
 2051                 panic("vop_closeextattr: vp: locked %d, expected %d", islocked_vp, 1);
 2052 #endif
 2053         a.a_commit = commit;
 2054         a.a_cred = cred;
 2055         a.a_p = p;
 2056         return (VCALL(vp, VOFFSET(vop_closeextattr), &a));
 2057 }
 2058 #endif
 2059 
 2060 const int vop_getextattr_vp_offsets[] = {
 2061         VOPARG_OFFSETOF(struct vop_getextattr_args,a_vp),
 2062         VDESC_NO_OFFSET
 2063 };
 2064 const struct vnodeop_desc vop_getextattr_desc = {
 2065         51,
 2066         "vop_getextattr",
 2067         0,
 2068         vop_getextattr_vp_offsets,
 2069         VDESC_NO_OFFSET,
 2070         VOPARG_OFFSETOF(struct vop_getextattr_args, a_cred),
 2071         VOPARG_OFFSETOF(struct vop_getextattr_args, a_p),
 2072         VDESC_NO_OFFSET,
 2073         NULL,
 2074 };
 2075 #ifdef VNODE_OP_NOINLINE
 2076 int
 2077 VOP_GETEXTATTR(vp, attrnamespace, name, uio, size, cred, p)
 2078         struct vnode *vp;
 2079         int attrnamespace;
 2080         const char *name;
 2081         struct uio *uio;
 2082         size_t *size;
 2083         struct ucred *cred;
 2084         struct proc *p;
 2085 {
 2086         struct vop_getextattr_args a;
 2087 #ifdef VNODE_LOCKDEBUG
 2088         int islocked_vp;
 2089 #endif
 2090         a.a_desc = VDESC(vop_getextattr);
 2091         a.a_vp = vp;
 2092 #ifdef VNODE_LOCKDEBUG
 2093         islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 2094         if (islocked_vp != 1)
 2095                 panic("vop_getextattr: vp: locked %d, expected %d", islocked_vp, 1);
 2096 #endif
 2097         a.a_attrnamespace = attrnamespace;
 2098         a.a_name = name;
 2099         a.a_uio = uio;
 2100         a.a_size = size;
 2101         a.a_cred = cred;
 2102         a.a_p = p;
 2103         return (VCALL(vp, VOFFSET(vop_getextattr), &a));
 2104 }
 2105 #endif
 2106 
 2107 const int vop_listextattr_vp_offsets[] = {
 2108         VOPARG_OFFSETOF(struct vop_listextattr_args,a_vp),
 2109         VDESC_NO_OFFSET
 2110 };
 2111 const struct vnodeop_desc vop_listextattr_desc = {
 2112         52,
 2113         "vop_listextattr",
 2114         0,
 2115         vop_listextattr_vp_offsets,
 2116         VDESC_NO_OFFSET,
 2117         VOPARG_OFFSETOF(struct vop_listextattr_args, a_cred),
 2118         VOPARG_OFFSETOF(struct vop_listextattr_args, a_p),
 2119         VDESC_NO_OFFSET,
 2120         NULL,
 2121 };
 2122 #ifdef VNODE_OP_NOINLINE
 2123 int
 2124 VOP_LISTEXTATTR(vp, attrnamespace, uio, size, cred, p)
 2125         struct vnode *vp;
 2126         int attrnamespace;
 2127         struct uio *uio;
 2128         size_t *size;
 2129         struct ucred *cred;
 2130         struct proc *p;
 2131 {
 2132         struct vop_listextattr_args a;
 2133 #ifdef VNODE_LOCKDEBUG
 2134         int islocked_vp;
 2135 #endif
 2136         a.a_desc = VDESC(vop_listextattr);
 2137         a.a_vp = vp;
 2138 #ifdef VNODE_LOCKDEBUG
 2139         islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 2140         if (islocked_vp != 1)
 2141                 panic("vop_listextattr: vp: locked %d, expected %d", islocked_vp, 1);
 2142 #endif
 2143         a.a_attrnamespace = attrnamespace;
 2144         a.a_uio = uio;
 2145         a.a_size = size;
 2146         a.a_cred = cred;
 2147         a.a_p = p;
 2148         return (VCALL(vp, VOFFSET(vop_listextattr), &a));
 2149 }
 2150 #endif
 2151 
 2152 const int vop_openextattr_vp_offsets[] = {
 2153         VOPARG_OFFSETOF(struct vop_openextattr_args,a_vp),
 2154         VDESC_NO_OFFSET
 2155 };
 2156 const struct vnodeop_desc vop_openextattr_desc = {
 2157         53,
 2158         "vop_openextattr",
 2159         0,
 2160         vop_openextattr_vp_offsets,
 2161         VDESC_NO_OFFSET,
 2162         VOPARG_OFFSETOF(struct vop_openextattr_args, a_cred),
 2163         VOPARG_OFFSETOF(struct vop_openextattr_args, a_p),
 2164         VDESC_NO_OFFSET,
 2165         NULL,
 2166 };
 2167 #ifdef VNODE_OP_NOINLINE
 2168 int
 2169 VOP_OPENEXTATTR(vp, cred, p)
 2170         struct vnode *vp;
 2171         struct ucred *cred;
 2172         struct proc *p;
 2173 {
 2174         struct vop_openextattr_args a;
 2175 #ifdef VNODE_LOCKDEBUG
 2176         int islocked_vp;
 2177 #endif
 2178         a.a_desc = VDESC(vop_openextattr);
 2179         a.a_vp = vp;
 2180 #ifdef VNODE_LOCKDEBUG
 2181         islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 2182         if (islocked_vp != 1)
 2183                 panic("vop_openextattr: vp: locked %d, expected %d", islocked_vp, 1);
 2184 #endif
 2185         a.a_cred = cred;
 2186         a.a_p = p;
 2187         return (VCALL(vp, VOFFSET(vop_openextattr), &a));
 2188 }
 2189 #endif
 2190 
 2191 const int vop_deleteextattr_vp_offsets[] = {
 2192         VOPARG_OFFSETOF(struct vop_deleteextattr_args,a_vp),
 2193         VDESC_NO_OFFSET
 2194 };
 2195 const struct vnodeop_desc vop_deleteextattr_desc = {
 2196         54,
 2197         "vop_deleteextattr",
 2198         0,
 2199         vop_deleteextattr_vp_offsets,
 2200         VDESC_NO_OFFSET,
 2201         VOPARG_OFFSETOF(struct vop_deleteextattr_args, a_cred),
 2202         VOPARG_OFFSETOF(struct vop_deleteextattr_args, a_p),
 2203         VDESC_NO_OFFSET,
 2204         NULL,
 2205 };
 2206 #ifdef VNODE_OP_NOINLINE
 2207 int
 2208 VOP_DELETEEXTATTR(vp, attrnamespace, name, cred, p)
 2209         struct vnode *vp;
 2210         int attrnamespace;
 2211         const char *name;
 2212         struct ucred *cred;
 2213         struct proc *p;
 2214 {
 2215         struct vop_deleteextattr_args a;
 2216 #ifdef VNODE_LOCKDEBUG
 2217         int islocked_vp;
 2218 #endif
 2219         a.a_desc = VDESC(vop_deleteextattr);
 2220         a.a_vp = vp;
 2221 #ifdef VNODE_LOCKDEBUG
 2222         islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 2223         if (islocked_vp != 1)
 2224                 panic("vop_deleteextattr: vp: locked %d, expected %d", islocked_vp, 1);
 2225 #endif
 2226         a.a_attrnamespace = attrnamespace;
 2227         a.a_name = name;
 2228         a.a_cred = cred;
 2229         a.a_p = p;
 2230         return (VCALL(vp, VOFFSET(vop_deleteextattr), &a));
 2231 }
 2232 #endif
 2233 
 2234 const int vop_setextattr_vp_offsets[] = {
 2235         VOPARG_OFFSETOF(struct vop_setextattr_args,a_vp),
 2236         VDESC_NO_OFFSET
 2237 };
 2238 const struct vnodeop_desc vop_setextattr_desc = {
 2239         55,
 2240         "vop_setextattr",
 2241         0,
 2242         vop_setextattr_vp_offsets,
 2243         VDESC_NO_OFFSET,
 2244         VOPARG_OFFSETOF(struct vop_setextattr_args, a_cred),
 2245         VOPARG_OFFSETOF(struct vop_setextattr_args, a_p),
 2246         VDESC_NO_OFFSET,
 2247         NULL,
 2248 };
 2249 #ifdef VNODE_OP_NOINLINE
 2250 int
 2251 VOP_SETEXTATTR(vp, attrnamespace, name, uio, cred, p)
 2252         struct vnode *vp;
 2253         int attrnamespace;
 2254         const char *name;
 2255         struct uio *uio;
 2256         struct ucred *cred;
 2257         struct proc *p;
 2258 {
 2259         struct vop_setextattr_args a;
 2260 #ifdef VNODE_LOCKDEBUG
 2261         int islocked_vp;
 2262 #endif
 2263         a.a_desc = VDESC(vop_setextattr);
 2264         a.a_vp = vp;
 2265 #ifdef VNODE_LOCKDEBUG
 2266         islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 2267         if (islocked_vp != 1)
 2268                 panic("vop_setextattr: vp: locked %d, expected %d", islocked_vp, 1);
 2269 #endif
 2270         a.a_attrnamespace = attrnamespace;
 2271         a.a_name = name;
 2272         a.a_uio = uio;
 2273         a.a_cred = cred;
 2274         a.a_p = p;
 2275         return (VCALL(vp, VOFFSET(vop_setextattr), &a));
 2276 }
 2277 #endif
 2278 
 2279 /* End of special cases. */
 2280 
 2281 const struct vnodeop_desc * const vfs_op_descs[] = {
 2282         &vop_default_desc,      /* MUST BE FIRST */
 2283         &vop_bwrite_desc,       /* XXX: SPECIAL CASE */
 2284 
 2285         &vop_lookup_desc,
 2286         &vop_create_desc,
 2287         &vop_mknod_desc,
 2288         &vop_open_desc,
 2289         &vop_close_desc,
 2290         &vop_access_desc,
 2291         &vop_getattr_desc,
 2292         &vop_setattr_desc,
 2293         &vop_read_desc,
 2294         &vop_write_desc,
 2295         &vop_ioctl_desc,
 2296         &vop_fcntl_desc,
 2297         &vop_poll_desc,
 2298         &vop_kqfilter_desc,
 2299         &vop_revoke_desc,
 2300         &vop_mmap_desc,
 2301         &vop_fsync_desc,
 2302         &vop_seek_desc,
 2303         &vop_remove_desc,
 2304         &vop_link_desc,
 2305         &vop_rename_desc,
 2306         &vop_mkdir_desc,
 2307         &vop_rmdir_desc,
 2308         &vop_symlink_desc,
 2309         &vop_readdir_desc,
 2310         &vop_readlink_desc,
 2311         &vop_abortop_desc,
 2312         &vop_inactive_desc,
 2313         &vop_reclaim_desc,
 2314         &vop_lock_desc,
 2315         &vop_unlock_desc,
 2316         &vop_bmap_desc,
 2317         &vop_strategy_desc,
 2318         &vop_print_desc,
 2319         &vop_islocked_desc,
 2320         &vop_pathconf_desc,
 2321         &vop_advlock_desc,
 2322         &vop_blkatoff_desc,
 2323         &vop_valloc_desc,
 2324         &vop_balloc_desc,
 2325         &vop_reallocblks_desc,
 2326         &vop_vfree_desc,
 2327         &vop_truncate_desc,
 2328         &vop_update_desc,
 2329         &vop_lease_desc,
 2330         &vop_whiteout_desc,
 2331         &vop_getpages_desc,
 2332         &vop_putpages_desc,
 2333         &vop_closeextattr_desc,
 2334         &vop_getextattr_desc,
 2335         &vop_listextattr_desc,
 2336         &vop_openextattr_desc,
 2337         &vop_deleteextattr_desc,
 2338         &vop_setextattr_desc,
 2339         NULL
 2340 };
 2341 

Cache object: 272809f8f30c7a35ecc0cf1a1eed881d


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