[BACK]Return to vnode_if.h CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / sys / sys

Annotation of src/sys/sys/vnode_if.h, Revision 1.14

1.9       thorpej     1: /*     $NetBSD$        */
                      2:
1.1       cgd         3: /*
                      4:  * Warning: This file is generated automatically.
                      5:  * (Modifications made here may easily be lost!)
                      6:  *
                      7:  * Created from the file:
1.12      kleink      8:  *     NetBSD: vnode_if.src,v 1.14 1998/06/05 19:38:56 kleink Exp
1.1       cgd         9:  * by the script:
1.14    ! christos   10:  *     NetBSD: vnode_if.sh,v 1.18 1998/09/13 14:44:34 christos Exp
1.1       cgd        11:  */
                     12:
                     13: /*
1.10      fvdl       14:  * Copyright (c) 1992, 1993, 1994, 1995
1.1       cgd        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. All advertising materials mentioning features or use of this software
                     26:  *    must display the following acknowledgement:
                     27:  *     This product includes software developed by the University of
                     28:  *     California, Berkeley and its contributors.
                     29:  * 4. Neither the name of the University nor the names of its contributors
                     30:  *    may be used to endorse or promote products derived from this software
                     31:  *    without specific prior written permission.
                     32:  *
1.14    ! christos   33:  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
1.1       cgd        34:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
                     35:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
                     36:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
                     37:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
                     38:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
                     39:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
                     40:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
                     41:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
                     42:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
                     43:  * SUCH DAMAGE.
                     44:  */
                     45:
1.4       mikel      46: #ifndef _SYS_VNODE_IF_H_
                     47: #define _SYS_VNODE_IF_H_
                     48:
1.1       cgd        49: extern struct vnodeop_desc vop_default_desc;
                     50:
                     51:
                     52: struct vop_lookup_args {
                     53:        struct vnodeop_desc *a_desc;
                     54:        struct vnode *a_dvp;
                     55:        struct vnode **a_vpp;
                     56:        struct componentname *a_cnp;
                     57: };
                     58: extern struct vnodeop_desc vop_lookup_desc;
                     59: static __inline int VOP_LOOKUP __P((struct vnode *, struct vnode **,
1.13      mycroft    60:     struct componentname *)) __attribute__((__unused__));
1.1       cgd        61: static __inline int VOP_LOOKUP(dvp, vpp, cnp)
                     62:        struct vnode *dvp;
                     63:        struct vnode **vpp;
                     64:        struct componentname *cnp;
                     65: {
                     66:        struct vop_lookup_args a;
                     67:        a.a_desc = VDESC(vop_lookup);
                     68:        a.a_dvp = dvp;
                     69:        a.a_vpp = vpp;
                     70:        a.a_cnp = cnp;
                     71:        return (VCALL(dvp, VOFFSET(vop_lookup), &a));
                     72: }
                     73:
                     74: struct vop_create_args {
                     75:        struct vnodeop_desc *a_desc;
                     76:        struct vnode *a_dvp;
                     77:        struct vnode **a_vpp;
                     78:        struct componentname *a_cnp;
                     79:        struct vattr *a_vap;
                     80: };
                     81: extern struct vnodeop_desc vop_create_desc;
                     82: static __inline int VOP_CREATE __P((struct vnode *, struct vnode **,
1.13      mycroft    83:     struct componentname *, struct vattr *)) __attribute__((__unused__));
1.1       cgd        84: static __inline int VOP_CREATE(dvp, vpp, cnp, vap)
                     85:        struct vnode *dvp;
                     86:        struct vnode **vpp;
                     87:        struct componentname *cnp;
                     88:        struct vattr *vap;
                     89: {
                     90:        struct vop_create_args a;
                     91:        a.a_desc = VDESC(vop_create);
                     92:        a.a_dvp = dvp;
                     93:        a.a_vpp = vpp;
                     94:        a.a_cnp = cnp;
                     95:        a.a_vap = vap;
                     96:        return (VCALL(dvp, VOFFSET(vop_create), &a));
                     97: }
                     98:
                     99: struct vop_mknod_args {
                    100:        struct vnodeop_desc *a_desc;
                    101:        struct vnode *a_dvp;
                    102:        struct vnode **a_vpp;
                    103:        struct componentname *a_cnp;
                    104:        struct vattr *a_vap;
                    105: };
                    106: extern struct vnodeop_desc vop_mknod_desc;
                    107: static __inline int VOP_MKNOD __P((struct vnode *, struct vnode **,
1.13      mycroft   108:     struct componentname *, struct vattr *)) __attribute__((__unused__));
1.1       cgd       109: static __inline int VOP_MKNOD(dvp, vpp, cnp, vap)
                    110:        struct vnode *dvp;
                    111:        struct vnode **vpp;
                    112:        struct componentname *cnp;
                    113:        struct vattr *vap;
                    114: {
                    115:        struct vop_mknod_args a;
                    116:        a.a_desc = VDESC(vop_mknod);
                    117:        a.a_dvp = dvp;
                    118:        a.a_vpp = vpp;
                    119:        a.a_cnp = cnp;
                    120:        a.a_vap = vap;
                    121:        return (VCALL(dvp, VOFFSET(vop_mknod), &a));
                    122: }
                    123:
                    124: struct vop_open_args {
                    125:        struct vnodeop_desc *a_desc;
                    126:        struct vnode *a_vp;
                    127:        int a_mode;
                    128:        struct ucred *a_cred;
                    129:        struct proc *a_p;
                    130: };
                    131: extern struct vnodeop_desc vop_open_desc;
                    132: static __inline int VOP_OPEN __P((struct vnode *, int, struct ucred *,
1.13      mycroft   133:     struct proc *)) __attribute__((__unused__));
1.1       cgd       134: static __inline int VOP_OPEN(vp, mode, cred, p)
                    135:        struct vnode *vp;
                    136:        int mode;
                    137:        struct ucred *cred;
                    138:        struct proc *p;
                    139: {
                    140:        struct vop_open_args a;
                    141:        a.a_desc = VDESC(vop_open);
                    142:        a.a_vp = vp;
                    143:        a.a_mode = mode;
                    144:        a.a_cred = cred;
                    145:        a.a_p = p;
                    146:        return (VCALL(vp, VOFFSET(vop_open), &a));
                    147: }
                    148:
                    149: struct vop_close_args {
                    150:        struct vnodeop_desc *a_desc;
                    151:        struct vnode *a_vp;
                    152:        int a_fflag;
                    153:        struct ucred *a_cred;
                    154:        struct proc *a_p;
                    155: };
                    156: extern struct vnodeop_desc vop_close_desc;
                    157: static __inline int VOP_CLOSE __P((struct vnode *, int, struct ucred *,
1.13      mycroft   158:     struct proc *)) __attribute__((__unused__));
1.1       cgd       159: static __inline int VOP_CLOSE(vp, fflag, cred, p)
                    160:        struct vnode *vp;
                    161:        int fflag;
                    162:        struct ucred *cred;
                    163:        struct proc *p;
                    164: {
                    165:        struct vop_close_args a;
                    166:        a.a_desc = VDESC(vop_close);
                    167:        a.a_vp = vp;
                    168:        a.a_fflag = fflag;
                    169:        a.a_cred = cred;
                    170:        a.a_p = p;
                    171:        return (VCALL(vp, VOFFSET(vop_close), &a));
                    172: }
                    173:
                    174: struct vop_access_args {
                    175:        struct vnodeop_desc *a_desc;
                    176:        struct vnode *a_vp;
                    177:        int a_mode;
                    178:        struct ucred *a_cred;
                    179:        struct proc *a_p;
                    180: };
                    181: extern struct vnodeop_desc vop_access_desc;
                    182: static __inline int VOP_ACCESS __P((struct vnode *, int, struct ucred *,
1.13      mycroft   183:     struct proc *)) __attribute__((__unused__));
1.1       cgd       184: static __inline int VOP_ACCESS(vp, mode, cred, p)
                    185:        struct vnode *vp;
                    186:        int mode;
                    187:        struct ucred *cred;
                    188:        struct proc *p;
                    189: {
                    190:        struct vop_access_args a;
                    191:        a.a_desc = VDESC(vop_access);
                    192:        a.a_vp = vp;
                    193:        a.a_mode = mode;
                    194:        a.a_cred = cred;
                    195:        a.a_p = p;
                    196:        return (VCALL(vp, VOFFSET(vop_access), &a));
                    197: }
                    198:
                    199: struct vop_getattr_args {
                    200:        struct vnodeop_desc *a_desc;
                    201:        struct vnode *a_vp;
                    202:        struct vattr *a_vap;
                    203:        struct ucred *a_cred;
                    204:        struct proc *a_p;
                    205: };
                    206: extern struct vnodeop_desc vop_getattr_desc;
                    207: static __inline int VOP_GETATTR __P((struct vnode *, struct vattr *,
1.13      mycroft   208:     struct ucred *, struct proc *)) __attribute__((__unused__));
1.1       cgd       209: static __inline int VOP_GETATTR(vp, vap, cred, p)
                    210:        struct vnode *vp;
                    211:        struct vattr *vap;
                    212:        struct ucred *cred;
                    213:        struct proc *p;
                    214: {
                    215:        struct vop_getattr_args a;
                    216:        a.a_desc = VDESC(vop_getattr);
                    217:        a.a_vp = vp;
                    218:        a.a_vap = vap;
                    219:        a.a_cred = cred;
                    220:        a.a_p = p;
                    221:        return (VCALL(vp, VOFFSET(vop_getattr), &a));
                    222: }
                    223:
                    224: struct vop_setattr_args {
                    225:        struct vnodeop_desc *a_desc;
                    226:        struct vnode *a_vp;
                    227:        struct vattr *a_vap;
                    228:        struct ucred *a_cred;
                    229:        struct proc *a_p;
                    230: };
                    231: extern struct vnodeop_desc vop_setattr_desc;
                    232: static __inline int VOP_SETATTR __P((struct vnode *, struct vattr *,
1.13      mycroft   233:     struct ucred *, struct proc *)) __attribute__((__unused__));
1.1       cgd       234: static __inline int VOP_SETATTR(vp, vap, cred, p)
                    235:        struct vnode *vp;
                    236:        struct vattr *vap;
                    237:        struct ucred *cred;
                    238:        struct proc *p;
                    239: {
                    240:        struct vop_setattr_args a;
                    241:        a.a_desc = VDESC(vop_setattr);
                    242:        a.a_vp = vp;
                    243:        a.a_vap = vap;
                    244:        a.a_cred = cred;
                    245:        a.a_p = p;
                    246:        return (VCALL(vp, VOFFSET(vop_setattr), &a));
                    247: }
                    248:
                    249: struct vop_read_args {
                    250:        struct vnodeop_desc *a_desc;
                    251:        struct vnode *a_vp;
                    252:        struct uio *a_uio;
                    253:        int a_ioflag;
                    254:        struct ucred *a_cred;
                    255: };
                    256: extern struct vnodeop_desc vop_read_desc;
                    257: static __inline int VOP_READ __P((struct vnode *, struct uio *, int,
1.13      mycroft   258:     struct ucred *)) __attribute__((__unused__));
1.1       cgd       259: static __inline int VOP_READ(vp, uio, ioflag, cred)
                    260:        struct vnode *vp;
                    261:        struct uio *uio;
                    262:        int ioflag;
                    263:        struct ucred *cred;
                    264: {
                    265:        struct vop_read_args a;
                    266:        a.a_desc = VDESC(vop_read);
                    267:        a.a_vp = vp;
                    268:        a.a_uio = uio;
                    269:        a.a_ioflag = ioflag;
                    270:        a.a_cred = cred;
                    271:        return (VCALL(vp, VOFFSET(vop_read), &a));
                    272: }
                    273:
                    274: struct vop_write_args {
                    275:        struct vnodeop_desc *a_desc;
                    276:        struct vnode *a_vp;
                    277:        struct uio *a_uio;
                    278:        int a_ioflag;
                    279:        struct ucred *a_cred;
                    280: };
                    281: extern struct vnodeop_desc vop_write_desc;
                    282: static __inline int VOP_WRITE __P((struct vnode *, struct uio *, int,
1.13      mycroft   283:     struct ucred *)) __attribute__((__unused__));
1.1       cgd       284: static __inline int VOP_WRITE(vp, uio, ioflag, cred)
                    285:        struct vnode *vp;
                    286:        struct uio *uio;
                    287:        int ioflag;
                    288:        struct ucred *cred;
                    289: {
                    290:        struct vop_write_args a;
                    291:        a.a_desc = VDESC(vop_write);
                    292:        a.a_vp = vp;
                    293:        a.a_uio = uio;
                    294:        a.a_ioflag = ioflag;
                    295:        a.a_cred = cred;
                    296:        return (VCALL(vp, VOFFSET(vop_write), &a));
                    297: }
                    298:
                    299: struct vop_ioctl_args {
                    300:        struct vnodeop_desc *a_desc;
                    301:        struct vnode *a_vp;
                    302:        u_long a_command;
                    303:        caddr_t a_data;
                    304:        int a_fflag;
                    305:        struct ucred *a_cred;
                    306:        struct proc *a_p;
                    307: };
                    308: extern struct vnodeop_desc vop_ioctl_desc;
                    309: static __inline int VOP_IOCTL __P((struct vnode *, u_long, caddr_t, int,
1.13      mycroft   310:     struct ucred *, struct proc *)) __attribute__((__unused__));
1.1       cgd       311: static __inline int VOP_IOCTL(vp, command, data, fflag, cred, p)
                    312:        struct vnode *vp;
                    313:        u_long command;
                    314:        caddr_t data;
                    315:        int fflag;
                    316:        struct ucred *cred;
                    317:        struct proc *p;
                    318: {
                    319:        struct vop_ioctl_args a;
                    320:        a.a_desc = VDESC(vop_ioctl);
                    321:        a.a_vp = vp;
                    322:        a.a_command = command;
                    323:        a.a_data = data;
                    324:        a.a_fflag = fflag;
                    325:        a.a_cred = cred;
                    326:        a.a_p = p;
                    327:        return (VCALL(vp, VOFFSET(vop_ioctl), &a));
                    328: }
                    329:
1.3       mycroft   330: struct vop_poll_args {
1.1       cgd       331:        struct vnodeop_desc *a_desc;
                    332:        struct vnode *a_vp;
1.3       mycroft   333:        int a_events;
1.1       cgd       334:        struct proc *a_p;
                    335: };
1.3       mycroft   336: extern struct vnodeop_desc vop_poll_desc;
1.5       cgd       337: static __inline int VOP_POLL __P((struct vnode *, int,
1.13      mycroft   338:     struct proc *)) __attribute__((__unused__));
1.3       mycroft   339: static __inline int VOP_POLL(vp, events, p)
1.1       cgd       340:        struct vnode *vp;
1.3       mycroft   341:        int events;
1.1       cgd       342:        struct proc *p;
                    343: {
1.3       mycroft   344:        struct vop_poll_args a;
                    345:        a.a_desc = VDESC(vop_poll);
1.1       cgd       346:        a.a_vp = vp;
1.3       mycroft   347:        a.a_events = events;
1.1       cgd       348:        a.a_p = p;
1.3       mycroft   349:        return (VCALL(vp, VOFFSET(vop_poll), &a));
1.1       cgd       350: }
                    351:
1.10      fvdl      352: struct vop_revoke_args {
                    353:        struct vnodeop_desc *a_desc;
                    354:        struct vnode *a_vp;
                    355:        int a_flags;
                    356: };
                    357: extern struct vnodeop_desc vop_revoke_desc;
                    358: static __inline int VOP_REVOKE __P((struct vnode *,
1.13      mycroft   359:     int)) __attribute__((__unused__));
1.10      fvdl      360: static __inline int VOP_REVOKE(vp, flags)
                    361:        struct vnode *vp;
                    362:        int flags;
                    363: {
                    364:        struct vop_revoke_args a;
                    365:        a.a_desc = VDESC(vop_revoke);
                    366:        a.a_vp = vp;
                    367:        a.a_flags = flags;
                    368:        return (VCALL(vp, VOFFSET(vop_revoke), &a));
                    369: }
                    370:
1.1       cgd       371: struct vop_mmap_args {
                    372:        struct vnodeop_desc *a_desc;
                    373:        struct vnode *a_vp;
                    374:        int a_fflags;
                    375:        struct ucred *a_cred;
                    376:        struct proc *a_p;
                    377: };
                    378: extern struct vnodeop_desc vop_mmap_desc;
                    379: static __inline int VOP_MMAP __P((struct vnode *, int, struct ucred *,
1.13      mycroft   380:     struct proc *)) __attribute__((__unused__));
1.1       cgd       381: static __inline int VOP_MMAP(vp, fflags, cred, p)
                    382:        struct vnode *vp;
                    383:        int fflags;
                    384:        struct ucred *cred;
                    385:        struct proc *p;
                    386: {
                    387:        struct vop_mmap_args a;
                    388:        a.a_desc = VDESC(vop_mmap);
                    389:        a.a_vp = vp;
                    390:        a.a_fflags = fflags;
                    391:        a.a_cred = cred;
                    392:        a.a_p = p;
                    393:        return (VCALL(vp, VOFFSET(vop_mmap), &a));
                    394: }
                    395:
                    396: struct vop_fsync_args {
                    397:        struct vnodeop_desc *a_desc;
                    398:        struct vnode *a_vp;
                    399:        struct ucred *a_cred;
1.12      kleink    400:        int a_flags;
1.1       cgd       401:        struct proc *a_p;
                    402: };
                    403: extern struct vnodeop_desc vop_fsync_desc;
                    404: static __inline int VOP_FSYNC __P((struct vnode *, struct ucred *, int,
1.13      mycroft   405:     struct proc *)) __attribute__((__unused__));
1.12      kleink    406: static __inline int VOP_FSYNC(vp, cred, flags, p)
1.1       cgd       407:        struct vnode *vp;
                    408:        struct ucred *cred;
1.12      kleink    409:        int flags;
1.1       cgd       410:        struct proc *p;
                    411: {
                    412:        struct vop_fsync_args a;
                    413:        a.a_desc = VDESC(vop_fsync);
                    414:        a.a_vp = vp;
                    415:        a.a_cred = cred;
1.12      kleink    416:        a.a_flags = flags;
1.1       cgd       417:        a.a_p = p;
                    418:        return (VCALL(vp, VOFFSET(vop_fsync), &a));
                    419: }
                    420:
                    421: struct vop_seek_args {
                    422:        struct vnodeop_desc *a_desc;
                    423:        struct vnode *a_vp;
                    424:        off_t a_oldoff;
                    425:        off_t a_newoff;
                    426:        struct ucred *a_cred;
                    427: };
                    428: extern struct vnodeop_desc vop_seek_desc;
                    429: static __inline int VOP_SEEK __P((struct vnode *, off_t, off_t,
1.13      mycroft   430:     struct ucred *)) __attribute__((__unused__));
1.1       cgd       431: static __inline int VOP_SEEK(vp, oldoff, newoff, cred)
                    432:        struct vnode *vp;
                    433:        off_t oldoff;
                    434:        off_t newoff;
                    435:        struct ucred *cred;
                    436: {
                    437:        struct vop_seek_args a;
                    438:        a.a_desc = VDESC(vop_seek);
                    439:        a.a_vp = vp;
                    440:        a.a_oldoff = oldoff;
                    441:        a.a_newoff = newoff;
                    442:        a.a_cred = cred;
                    443:        return (VCALL(vp, VOFFSET(vop_seek), &a));
                    444: }
                    445:
                    446: struct vop_remove_args {
                    447:        struct vnodeop_desc *a_desc;
                    448:        struct vnode *a_dvp;
                    449:        struct vnode *a_vp;
                    450:        struct componentname *a_cnp;
                    451: };
                    452: extern struct vnodeop_desc vop_remove_desc;
                    453: static __inline int VOP_REMOVE __P((struct vnode *, struct vnode *,
1.13      mycroft   454:     struct componentname *)) __attribute__((__unused__));
1.1       cgd       455: static __inline int VOP_REMOVE(dvp, vp, cnp)
                    456:        struct vnode *dvp;
                    457:        struct vnode *vp;
                    458:        struct componentname *cnp;
                    459: {
                    460:        struct vop_remove_args a;
                    461:        a.a_desc = VDESC(vop_remove);
                    462:        a.a_dvp = dvp;
                    463:        a.a_vp = vp;
                    464:        a.a_cnp = cnp;
                    465:        return (VCALL(dvp, VOFFSET(vop_remove), &a));
                    466: }
                    467:
                    468: struct vop_link_args {
                    469:        struct vnodeop_desc *a_desc;
                    470:        struct vnode *a_dvp;
                    471:        struct vnode *a_vp;
                    472:        struct componentname *a_cnp;
                    473: };
                    474: extern struct vnodeop_desc vop_link_desc;
                    475: static __inline int VOP_LINK __P((struct vnode *, struct vnode *,
1.13      mycroft   476:     struct componentname *)) __attribute__((__unused__));
1.1       cgd       477: static __inline int VOP_LINK(dvp, vp, cnp)
                    478:        struct vnode *dvp;
                    479:        struct vnode *vp;
                    480:        struct componentname *cnp;
                    481: {
                    482:        struct vop_link_args a;
                    483:        a.a_desc = VDESC(vop_link);
                    484:        a.a_dvp = dvp;
                    485:        a.a_vp = vp;
                    486:        a.a_cnp = cnp;
                    487:        return (VCALL(dvp, VOFFSET(vop_link), &a));
                    488: }
                    489:
                    490: struct vop_rename_args {
                    491:        struct vnodeop_desc *a_desc;
                    492:        struct vnode *a_fdvp;
                    493:        struct vnode *a_fvp;
                    494:        struct componentname *a_fcnp;
                    495:        struct vnode *a_tdvp;
                    496:        struct vnode *a_tvp;
                    497:        struct componentname *a_tcnp;
                    498: };
                    499: extern struct vnodeop_desc vop_rename_desc;
                    500: static __inline int VOP_RENAME __P((struct vnode *, struct vnode *,
                    501:     struct componentname *, struct vnode *, struct vnode *,
1.13      mycroft   502:     struct componentname *)) __attribute__((__unused__));
1.1       cgd       503: static __inline int VOP_RENAME(fdvp, fvp, fcnp, tdvp, tvp, tcnp)
                    504:        struct vnode *fdvp;
                    505:        struct vnode *fvp;
                    506:        struct componentname *fcnp;
                    507:        struct vnode *tdvp;
                    508:        struct vnode *tvp;
                    509:        struct componentname *tcnp;
                    510: {
                    511:        struct vop_rename_args a;
                    512:        a.a_desc = VDESC(vop_rename);
                    513:        a.a_fdvp = fdvp;
                    514:        a.a_fvp = fvp;
                    515:        a.a_fcnp = fcnp;
                    516:        a.a_tdvp = tdvp;
                    517:        a.a_tvp = tvp;
                    518:        a.a_tcnp = tcnp;
                    519:        return (VCALL(fdvp, VOFFSET(vop_rename), &a));
                    520: }
                    521:
                    522: struct vop_mkdir_args {
                    523:        struct vnodeop_desc *a_desc;
                    524:        struct vnode *a_dvp;
                    525:        struct vnode **a_vpp;
                    526:        struct componentname *a_cnp;
                    527:        struct vattr *a_vap;
                    528: };
                    529: extern struct vnodeop_desc vop_mkdir_desc;
                    530: static __inline int VOP_MKDIR __P((struct vnode *, struct vnode **,
1.13      mycroft   531:     struct componentname *, struct vattr *)) __attribute__((__unused__));
1.1       cgd       532: static __inline int VOP_MKDIR(dvp, vpp, cnp, vap)
                    533:        struct vnode *dvp;
                    534:        struct vnode **vpp;
                    535:        struct componentname *cnp;
                    536:        struct vattr *vap;
                    537: {
                    538:        struct vop_mkdir_args a;
                    539:        a.a_desc = VDESC(vop_mkdir);
                    540:        a.a_dvp = dvp;
                    541:        a.a_vpp = vpp;
                    542:        a.a_cnp = cnp;
                    543:        a.a_vap = vap;
                    544:        return (VCALL(dvp, VOFFSET(vop_mkdir), &a));
                    545: }
                    546:
                    547: struct vop_rmdir_args {
                    548:        struct vnodeop_desc *a_desc;
                    549:        struct vnode *a_dvp;
                    550:        struct vnode *a_vp;
                    551:        struct componentname *a_cnp;
                    552: };
                    553: extern struct vnodeop_desc vop_rmdir_desc;
                    554: static __inline int VOP_RMDIR __P((struct vnode *, struct vnode *,
1.13      mycroft   555:     struct componentname *)) __attribute__((__unused__));
1.1       cgd       556: static __inline int VOP_RMDIR(dvp, vp, cnp)
                    557:        struct vnode *dvp;
                    558:        struct vnode *vp;
                    559:        struct componentname *cnp;
                    560: {
                    561:        struct vop_rmdir_args a;
                    562:        a.a_desc = VDESC(vop_rmdir);
                    563:        a.a_dvp = dvp;
                    564:        a.a_vp = vp;
                    565:        a.a_cnp = cnp;
                    566:        return (VCALL(dvp, VOFFSET(vop_rmdir), &a));
                    567: }
                    568:
                    569: struct vop_symlink_args {
                    570:        struct vnodeop_desc *a_desc;
                    571:        struct vnode *a_dvp;
                    572:        struct vnode **a_vpp;
                    573:        struct componentname *a_cnp;
                    574:        struct vattr *a_vap;
                    575:        char *a_target;
                    576: };
                    577: extern struct vnodeop_desc vop_symlink_desc;
                    578: static __inline int VOP_SYMLINK __P((struct vnode *, struct vnode **,
1.13      mycroft   579:     struct componentname *, struct vattr *,
                    580:     char *)) __attribute__((__unused__));
1.1       cgd       581: static __inline int VOP_SYMLINK(dvp, vpp, cnp, vap, target)
                    582:        struct vnode *dvp;
                    583:        struct vnode **vpp;
                    584:        struct componentname *cnp;
                    585:        struct vattr *vap;
                    586:        char *target;
                    587: {
                    588:        struct vop_symlink_args a;
                    589:        a.a_desc = VDESC(vop_symlink);
                    590:        a.a_dvp = dvp;
                    591:        a.a_vpp = vpp;
                    592:        a.a_cnp = cnp;
                    593:        a.a_vap = vap;
                    594:        a.a_target = target;
                    595:        return (VCALL(dvp, VOFFSET(vop_symlink), &a));
                    596: }
                    597:
                    598: struct vop_readdir_args {
                    599:        struct vnodeop_desc *a_desc;
                    600:        struct vnode *a_vp;
                    601:        struct uio *a_uio;
                    602:        struct ucred *a_cred;
                    603:        int *a_eofflag;
1.10      fvdl      604:        off_t **a_cookies;
                    605:        int *a_ncookies;
1.1       cgd       606: };
                    607: extern struct vnodeop_desc vop_readdir_desc;
                    608: static __inline int VOP_READDIR __P((struct vnode *, struct uio *,
1.13      mycroft   609:     struct ucred *, int *, off_t **, int *)) __attribute__((__unused__));
1.1       cgd       610: static __inline int VOP_READDIR(vp, uio, cred, eofflag, cookies, ncookies)
                    611:        struct vnode *vp;
                    612:        struct uio *uio;
                    613:        struct ucred *cred;
                    614:        int *eofflag;
1.10      fvdl      615:        off_t **cookies;
                    616:        int *ncookies;
1.1       cgd       617: {
                    618:        struct vop_readdir_args a;
                    619:        a.a_desc = VDESC(vop_readdir);
                    620:        a.a_vp = vp;
                    621:        a.a_uio = uio;
                    622:        a.a_cred = cred;
                    623:        a.a_eofflag = eofflag;
                    624:        a.a_cookies = cookies;
                    625:        a.a_ncookies = ncookies;
                    626:        return (VCALL(vp, VOFFSET(vop_readdir), &a));
                    627: }
                    628:
                    629: struct vop_readlink_args {
                    630:        struct vnodeop_desc *a_desc;
                    631:        struct vnode *a_vp;
                    632:        struct uio *a_uio;
                    633:        struct ucred *a_cred;
                    634: };
                    635: extern struct vnodeop_desc vop_readlink_desc;
                    636: static __inline int VOP_READLINK __P((struct vnode *, struct uio *,
1.13      mycroft   637:     struct ucred *)) __attribute__((__unused__));
1.1       cgd       638: static __inline int VOP_READLINK(vp, uio, cred)
                    639:        struct vnode *vp;
                    640:        struct uio *uio;
                    641:        struct ucred *cred;
                    642: {
                    643:        struct vop_readlink_args a;
                    644:        a.a_desc = VDESC(vop_readlink);
                    645:        a.a_vp = vp;
                    646:        a.a_uio = uio;
                    647:        a.a_cred = cred;
                    648:        return (VCALL(vp, VOFFSET(vop_readlink), &a));
                    649: }
                    650:
                    651: struct vop_abortop_args {
                    652:        struct vnodeop_desc *a_desc;
                    653:        struct vnode *a_dvp;
                    654:        struct componentname *a_cnp;
                    655: };
                    656: extern struct vnodeop_desc vop_abortop_desc;
1.5       cgd       657: static __inline int VOP_ABORTOP __P((struct vnode *,
1.13      mycroft   658:     struct componentname *)) __attribute__((__unused__));
1.1       cgd       659: static __inline int VOP_ABORTOP(dvp, cnp)
                    660:        struct vnode *dvp;
                    661:        struct componentname *cnp;
                    662: {
                    663:        struct vop_abortop_args a;
                    664:        a.a_desc = VDESC(vop_abortop);
                    665:        a.a_dvp = dvp;
                    666:        a.a_cnp = cnp;
                    667:        return (VCALL(dvp, VOFFSET(vop_abortop), &a));
                    668: }
                    669:
                    670: struct vop_inactive_args {
                    671:        struct vnodeop_desc *a_desc;
                    672:        struct vnode *a_vp;
1.10      fvdl      673:        struct proc *a_p;
1.1       cgd       674: };
                    675: extern struct vnodeop_desc vop_inactive_desc;
1.10      fvdl      676: static __inline int VOP_INACTIVE __P((struct vnode *,
1.13      mycroft   677:     struct proc *)) __attribute__((__unused__));
1.10      fvdl      678: static __inline int VOP_INACTIVE(vp, p)
1.1       cgd       679:        struct vnode *vp;
1.10      fvdl      680:        struct proc *p;
1.1       cgd       681: {
                    682:        struct vop_inactive_args a;
                    683:        a.a_desc = VDESC(vop_inactive);
                    684:        a.a_vp = vp;
1.10      fvdl      685:        a.a_p = p;
1.1       cgd       686:        return (VCALL(vp, VOFFSET(vop_inactive), &a));
                    687: }
                    688:
                    689: struct vop_reclaim_args {
                    690:        struct vnodeop_desc *a_desc;
                    691:        struct vnode *a_vp;
1.10      fvdl      692:        struct proc *a_p;
1.1       cgd       693: };
                    694: extern struct vnodeop_desc vop_reclaim_desc;
1.10      fvdl      695: static __inline int VOP_RECLAIM __P((struct vnode *,
1.13      mycroft   696:     struct proc *)) __attribute__((__unused__));
1.10      fvdl      697: static __inline int VOP_RECLAIM(vp, p)
1.1       cgd       698:        struct vnode *vp;
1.10      fvdl      699:        struct proc *p;
1.1       cgd       700: {
                    701:        struct vop_reclaim_args a;
                    702:        a.a_desc = VDESC(vop_reclaim);
                    703:        a.a_vp = vp;
1.10      fvdl      704:        a.a_p = p;
1.1       cgd       705:        return (VCALL(vp, VOFFSET(vop_reclaim), &a));
                    706: }
                    707:
                    708: struct vop_lock_args {
                    709:        struct vnodeop_desc *a_desc;
                    710:        struct vnode *a_vp;
1.10      fvdl      711:        int a_flags;
1.1       cgd       712: };
                    713: extern struct vnodeop_desc vop_lock_desc;
1.10      fvdl      714: static __inline int VOP_LOCK __P((struct vnode *,
1.13      mycroft   715:     int)) __attribute__((__unused__));
1.10      fvdl      716: static __inline int VOP_LOCK(vp, flags)
1.1       cgd       717:        struct vnode *vp;
1.10      fvdl      718:        int flags;
1.1       cgd       719: {
                    720:        struct vop_lock_args a;
                    721:        a.a_desc = VDESC(vop_lock);
                    722:        a.a_vp = vp;
1.10      fvdl      723:        a.a_flags = flags;
1.1       cgd       724:        return (VCALL(vp, VOFFSET(vop_lock), &a));
                    725: }
                    726:
                    727: struct vop_unlock_args {
                    728:        struct vnodeop_desc *a_desc;
                    729:        struct vnode *a_vp;
1.10      fvdl      730:        int a_flags;
1.1       cgd       731: };
                    732: extern struct vnodeop_desc vop_unlock_desc;
1.10      fvdl      733: static __inline int VOP_UNLOCK __P((struct vnode *,
1.13      mycroft   734:     int)) __attribute__((__unused__));
1.10      fvdl      735: static __inline int VOP_UNLOCK(vp, flags)
1.1       cgd       736:        struct vnode *vp;
1.10      fvdl      737:        int flags;
1.1       cgd       738: {
                    739:        struct vop_unlock_args a;
                    740:        a.a_desc = VDESC(vop_unlock);
                    741:        a.a_vp = vp;
1.10      fvdl      742:        a.a_flags = flags;
1.1       cgd       743:        return (VCALL(vp, VOFFSET(vop_unlock), &a));
                    744: }
                    745:
                    746: struct vop_bmap_args {
                    747:        struct vnodeop_desc *a_desc;
                    748:        struct vnode *a_vp;
                    749:        daddr_t a_bn;
                    750:        struct vnode **a_vpp;
                    751:        daddr_t *a_bnp;
                    752:        int *a_runp;
                    753: };
                    754: extern struct vnodeop_desc vop_bmap_desc;
                    755: static __inline int VOP_BMAP __P((struct vnode *, daddr_t, struct vnode **,
1.13      mycroft   756:     daddr_t *, int *)) __attribute__((__unused__));
1.1       cgd       757: static __inline int VOP_BMAP(vp, bn, vpp, bnp, runp)
                    758:        struct vnode *vp;
                    759:        daddr_t bn;
                    760:        struct vnode **vpp;
                    761:        daddr_t *bnp;
                    762:        int *runp;
                    763: {
                    764:        struct vop_bmap_args a;
                    765:        a.a_desc = VDESC(vop_bmap);
                    766:        a.a_vp = vp;
                    767:        a.a_bn = bn;
                    768:        a.a_vpp = vpp;
                    769:        a.a_bnp = bnp;
                    770:        a.a_runp = runp;
                    771:        return (VCALL(vp, VOFFSET(vop_bmap), &a));
                    772: }
                    773:
                    774: struct vop_print_args {
                    775:        struct vnodeop_desc *a_desc;
                    776:        struct vnode *a_vp;
                    777: };
                    778: extern struct vnodeop_desc vop_print_desc;
1.13      mycroft   779: static __inline int VOP_PRINT __P((struct vnode *)) __attribute__((__unused__));
1.1       cgd       780: static __inline int VOP_PRINT(vp)
                    781:        struct vnode *vp;
                    782: {
                    783:        struct vop_print_args a;
                    784:        a.a_desc = VDESC(vop_print);
                    785:        a.a_vp = vp;
                    786:        return (VCALL(vp, VOFFSET(vop_print), &a));
                    787: }
                    788:
                    789: struct vop_islocked_args {
                    790:        struct vnodeop_desc *a_desc;
                    791:        struct vnode *a_vp;
                    792: };
                    793: extern struct vnodeop_desc vop_islocked_desc;
1.13      mycroft   794: static __inline int VOP_ISLOCKED __P((
                    795:     struct vnode *)) __attribute__((__unused__));
1.1       cgd       796: static __inline int VOP_ISLOCKED(vp)
                    797:        struct vnode *vp;
                    798: {
                    799:        struct vop_islocked_args a;
                    800:        a.a_desc = VDESC(vop_islocked);
                    801:        a.a_vp = vp;
                    802:        return (VCALL(vp, VOFFSET(vop_islocked), &a));
                    803: }
                    804:
                    805: struct vop_pathconf_args {
                    806:        struct vnodeop_desc *a_desc;
                    807:        struct vnode *a_vp;
                    808:        int a_name;
                    809:        register_t *a_retval;
                    810: };
                    811: extern struct vnodeop_desc vop_pathconf_desc;
1.5       cgd       812: static __inline int VOP_PATHCONF __P((struct vnode *, int,
1.13      mycroft   813:     register_t *)) __attribute__((__unused__));
1.1       cgd       814: static __inline int VOP_PATHCONF(vp, name, retval)
                    815:        struct vnode *vp;
                    816:        int name;
                    817:        register_t *retval;
                    818: {
                    819:        struct vop_pathconf_args a;
                    820:        a.a_desc = VDESC(vop_pathconf);
                    821:        a.a_vp = vp;
                    822:        a.a_name = name;
                    823:        a.a_retval = retval;
                    824:        return (VCALL(vp, VOFFSET(vop_pathconf), &a));
                    825: }
                    826:
                    827: struct vop_advlock_args {
                    828:        struct vnodeop_desc *a_desc;
                    829:        struct vnode *a_vp;
                    830:        caddr_t a_id;
                    831:        int a_op;
                    832:        struct flock *a_fl;
                    833:        int a_flags;
                    834: };
                    835: extern struct vnodeop_desc vop_advlock_desc;
                    836: static __inline int VOP_ADVLOCK __P((struct vnode *, caddr_t, int,
1.13      mycroft   837:     struct flock *, int)) __attribute__((__unused__));
1.1       cgd       838: static __inline int VOP_ADVLOCK(vp, id, op, fl, flags)
                    839:        struct vnode *vp;
                    840:        caddr_t id;
                    841:        int op;
                    842:        struct flock *fl;
                    843:        int flags;
                    844: {
                    845:        struct vop_advlock_args a;
                    846:        a.a_desc = VDESC(vop_advlock);
                    847:        a.a_vp = vp;
                    848:        a.a_id = id;
                    849:        a.a_op = op;
                    850:        a.a_fl = fl;
                    851:        a.a_flags = flags;
                    852:        return (VCALL(vp, VOFFSET(vop_advlock), &a));
                    853: }
                    854:
                    855: struct vop_blkatoff_args {
                    856:        struct vnodeop_desc *a_desc;
                    857:        struct vnode *a_vp;
                    858:        off_t a_offset;
                    859:        char **a_res;
                    860:        struct buf **a_bpp;
                    861: };
                    862: extern struct vnodeop_desc vop_blkatoff_desc;
                    863: static __inline int VOP_BLKATOFF __P((struct vnode *, off_t, char **,
1.13      mycroft   864:     struct buf **)) __attribute__((__unused__));
1.1       cgd       865: static __inline int VOP_BLKATOFF(vp, offset, res, bpp)
                    866:        struct vnode *vp;
                    867:        off_t offset;
                    868:        char **res;
                    869:        struct buf **bpp;
                    870: {
                    871:        struct vop_blkatoff_args a;
                    872:        a.a_desc = VDESC(vop_blkatoff);
                    873:        a.a_vp = vp;
                    874:        a.a_offset = offset;
                    875:        a.a_res = res;
                    876:        a.a_bpp = bpp;
                    877:        return (VCALL(vp, VOFFSET(vop_blkatoff), &a));
                    878: }
                    879:
                    880: struct vop_valloc_args {
                    881:        struct vnodeop_desc *a_desc;
                    882:        struct vnode *a_pvp;
                    883:        int a_mode;
                    884:        struct ucred *a_cred;
                    885:        struct vnode **a_vpp;
                    886: };
                    887: extern struct vnodeop_desc vop_valloc_desc;
                    888: static __inline int VOP_VALLOC __P((struct vnode *, int, struct ucred *,
1.13      mycroft   889:     struct vnode **)) __attribute__((__unused__));
1.1       cgd       890: static __inline int VOP_VALLOC(pvp, mode, cred, vpp)
                    891:        struct vnode *pvp;
                    892:        int mode;
                    893:        struct ucred *cred;
                    894:        struct vnode **vpp;
                    895: {
                    896:        struct vop_valloc_args a;
                    897:        a.a_desc = VDESC(vop_valloc);
                    898:        a.a_pvp = pvp;
                    899:        a.a_mode = mode;
                    900:        a.a_cred = cred;
                    901:        a.a_vpp = vpp;
                    902:        return (VCALL(pvp, VOFFSET(vop_valloc), &a));
                    903: }
                    904:
                    905: struct vop_reallocblks_args {
                    906:        struct vnodeop_desc *a_desc;
                    907:        struct vnode *a_vp;
                    908:        struct cluster_save *a_buflist;
                    909: };
                    910: extern struct vnodeop_desc vop_reallocblks_desc;
                    911: static __inline int VOP_REALLOCBLKS __P((struct vnode *,
1.13      mycroft   912:     struct cluster_save *)) __attribute__((__unused__));
1.1       cgd       913: static __inline int VOP_REALLOCBLKS(vp, buflist)
                    914:        struct vnode *vp;
                    915:        struct cluster_save *buflist;
                    916: {
                    917:        struct vop_reallocblks_args a;
                    918:        a.a_desc = VDESC(vop_reallocblks);
                    919:        a.a_vp = vp;
                    920:        a.a_buflist = buflist;
                    921:        return (VCALL(vp, VOFFSET(vop_reallocblks), &a));
                    922: }
                    923:
                    924: struct vop_vfree_args {
                    925:        struct vnodeop_desc *a_desc;
                    926:        struct vnode *a_pvp;
                    927:        ino_t a_ino;
                    928:        int a_mode;
                    929: };
                    930: extern struct vnodeop_desc vop_vfree_desc;
1.5       cgd       931: static __inline int VOP_VFREE __P((struct vnode *, ino_t,
1.13      mycroft   932:     int)) __attribute__((__unused__));
1.1       cgd       933: static __inline int VOP_VFREE(pvp, ino, mode)
                    934:        struct vnode *pvp;
                    935:        ino_t ino;
                    936:        int mode;
                    937: {
                    938:        struct vop_vfree_args a;
                    939:        a.a_desc = VDESC(vop_vfree);
                    940:        a.a_pvp = pvp;
                    941:        a.a_ino = ino;
                    942:        a.a_mode = mode;
                    943:        return (VCALL(pvp, VOFFSET(vop_vfree), &a));
                    944: }
                    945:
                    946: struct vop_truncate_args {
                    947:        struct vnodeop_desc *a_desc;
                    948:        struct vnode *a_vp;
                    949:        off_t a_length;
                    950:        int a_flags;
                    951:        struct ucred *a_cred;
                    952:        struct proc *a_p;
                    953: };
                    954: extern struct vnodeop_desc vop_truncate_desc;
                    955: static __inline int VOP_TRUNCATE __P((struct vnode *, off_t, int,
1.13      mycroft   956:     struct ucred *, struct proc *)) __attribute__((__unused__));
1.1       cgd       957: static __inline int VOP_TRUNCATE(vp, length, flags, cred, p)
                    958:        struct vnode *vp;
                    959:        off_t length;
                    960:        int flags;
                    961:        struct ucred *cred;
                    962:        struct proc *p;
                    963: {
                    964:        struct vop_truncate_args a;
                    965:        a.a_desc = VDESC(vop_truncate);
                    966:        a.a_vp = vp;
                    967:        a.a_length = length;
                    968:        a.a_flags = flags;
                    969:        a.a_cred = cred;
                    970:        a.a_p = p;
                    971:        return (VCALL(vp, VOFFSET(vop_truncate), &a));
                    972: }
                    973:
                    974: struct vop_update_args {
                    975:        struct vnodeop_desc *a_desc;
                    976:        struct vnode *a_vp;
1.2       mycroft   977:        struct timespec *a_access;
                    978:        struct timespec *a_modify;
1.1       cgd       979:        int a_waitfor;
                    980: };
                    981: extern struct vnodeop_desc vop_update_desc;
1.2       mycroft   982: static __inline int VOP_UPDATE __P((struct vnode *, struct timespec *,
1.13      mycroft   983:     struct timespec *, int)) __attribute__((__unused__));
1.1       cgd       984: static __inline int VOP_UPDATE(vp, access, modify, waitfor)
                    985:        struct vnode *vp;
1.2       mycroft   986:        struct timespec *access;
                    987:        struct timespec *modify;
1.1       cgd       988:        int waitfor;
                    989: {
                    990:        struct vop_update_args a;
                    991:        a.a_desc = VDESC(vop_update);
                    992:        a.a_vp = vp;
                    993:        a.a_access = access;
                    994:        a.a_modify = modify;
                    995:        a.a_waitfor = waitfor;
                    996:        return (VCALL(vp, VOFFSET(vop_update), &a));
                    997: }
                    998:
                    999: struct vop_lease_args {
                   1000:        struct vnodeop_desc *a_desc;
                   1001:        struct vnode *a_vp;
                   1002:        struct proc *a_p;
                   1003:        struct ucred *a_cred;
                   1004:        int a_flag;
                   1005: };
                   1006: extern struct vnodeop_desc vop_lease_desc;
                   1007: static __inline int VOP_LEASE __P((struct vnode *, struct proc *,
1.13      mycroft  1008:     struct ucred *, int)) __attribute__((__unused__));
1.1       cgd      1009: static __inline int VOP_LEASE(vp, p, cred, flag)
                   1010:        struct vnode *vp;
                   1011:        struct proc *p;
                   1012:        struct ucred *cred;
                   1013:        int flag;
                   1014: {
                   1015:        struct vop_lease_args a;
                   1016:        a.a_desc = VDESC(vop_lease);
                   1017:        a.a_vp = vp;
                   1018:        a.a_p = p;
                   1019:        a.a_cred = cred;
                   1020:        a.a_flag = flag;
                   1021:        return (VCALL(vp, VOFFSET(vop_lease), &a));
                   1022: }
                   1023:
                   1024: struct vop_whiteout_args {
                   1025:        struct vnodeop_desc *a_desc;
                   1026:        struct vnode *a_dvp;
                   1027:        struct componentname *a_cnp;
                   1028:        int a_flags;
                   1029: };
                   1030: extern struct vnodeop_desc vop_whiteout_desc;
                   1031: static __inline int VOP_WHITEOUT __P((struct vnode *,
1.13      mycroft  1032:     struct componentname *, int)) __attribute__((__unused__));
1.1       cgd      1033: static __inline int VOP_WHITEOUT(dvp, cnp, flags)
                   1034:        struct vnode *dvp;
                   1035:        struct componentname *cnp;
                   1036:        int flags;
                   1037: {
                   1038:        struct vop_whiteout_args a;
                   1039:        a.a_desc = VDESC(vop_whiteout);
                   1040:        a.a_dvp = dvp;
                   1041:        a.a_cnp = cnp;
                   1042:        a.a_flags = flags;
                   1043:        return (VCALL(dvp, VOFFSET(vop_whiteout), &a));
                   1044: }
                   1045:
                   1046: /* Special cases: */
                   1047: #include <sys/buf.h>
                   1048:
                   1049: struct vop_strategy_args {
                   1050:        struct vnodeop_desc *a_desc;
                   1051:        struct buf *a_bp;
                   1052: };
                   1053: extern struct vnodeop_desc vop_strategy_desc;
1.13      mycroft  1054: static __inline int VOP_STRATEGY __P((
                   1055:     struct buf *)) __attribute__((__unused__));
1.1       cgd      1056: static __inline int VOP_STRATEGY(bp)
                   1057:        struct buf *bp;
                   1058: {
                   1059:        struct vop_strategy_args a;
                   1060:        a.a_desc = VDESC(vop_strategy);
                   1061:        a.a_bp = bp;
                   1062:        return (VCALL(bp->b_vp, VOFFSET(vop_strategy), &a));
                   1063: }
                   1064:
                   1065: struct vop_bwrite_args {
                   1066:        struct vnodeop_desc *a_desc;
                   1067:        struct buf *a_bp;
                   1068: };
                   1069: extern struct vnodeop_desc vop_bwrite_desc;
1.13      mycroft  1070: static __inline int VOP_BWRITE __P((struct buf *)) __attribute__((__unused__));
1.1       cgd      1071: static __inline int VOP_BWRITE(bp)
                   1072:        struct buf *bp;
                   1073: {
                   1074:        struct vop_bwrite_args a;
                   1075:        a.a_desc = VDESC(vop_bwrite);
                   1076:        a.a_bp = bp;
                   1077:        return (VCALL(bp->b_vp, VOFFSET(vop_bwrite), &a));
                   1078: }
                   1079:
                   1080: /* End of special cases. */
1.4       mikel    1081:
                   1082: #endif /* !_SYS_VNODE_IF_H_ */

CVSweb <webmaster@jp.NetBSD.org>