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/sys/vnode_if.h

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

Cache object: 6e924c76f850af1363ed7d201dc114bd


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