bsd/sys/vnode_if.h

   1
   2 /*
   3  * Copyright (c) 2000-2002 Apple Computer, Inc. All rights reserved.
   4  *
   5  * @APPLE_LICENSE_HEADER_START@
   6  *
   7  * The contents of this file constitute Original Code as defined in and
   8  * are subject to the Apple Public Source License Version 1.1 (the
   9  * "License").  You may not use this file except in compliance with the
  10  * License.  Please obtain a copy of the License at
  11  * http://www.apple.com/publicsource and read it before using this file.
  12  *
  13  * This Original Code and all software distributed under the License are
  14  * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  15  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  16  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
  18  * License for the specific language governing rights and limitations
  19  * under the License.
  20  *
  21  * @APPLE_LICENSE_HEADER_END@
  22  */
  23 /*
  24  * Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved
  25  * Copyright (c) 1992, 1993, 1994, 1995
  26  *      The Regents of the University of California.  All rights reserved.
  27  *
  28  * Redistribution and use in source and binary forms, with or without
  29  * modification, are permitted provided that the following conditions
  30  * are met:
  31  * 1. Redistributions of source code must retain the above copyright
  32  *    notice, this list of conditions and the following disclaimer.
  33  * 2. Redistributions in binary form must reproduce the above copyright
  34  *    notice, this list of conditions and the following disclaimer in the
  35  *    documentation and/or other materials provided with the distribution.
  36  * 3. All advertising materials mentioning features or use of this software
  37  *    must display the following acknowledgement:
  38  *      This product includes software developed by the University of
  39  *      California, Berkeley and its contributors.
  40  * 4. Neither the name of the University nor the names of its contributors
  41  *    may be used to endorse or promote products derived from this software
  42  *    without specific prior written permission.
  43  *
  44  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS AND
  45  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  46  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  47  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  48  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  49  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  50  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  51  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  52  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  53  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  54  * SUCH DAMAGE.
  55  */
  56
  57
  58 /*
  59  * Warning: This file is generated automatically.
  60  * (Modifications made here may easily be lost!)
  61  *
  62  * Created by the script:
  63  *      @(#)vnode_if.sh 8.7 (Berkeley) 5/11/95
  64  */
  65
  66
  67 #ifndef _SYS_VNODE_IF_H_
  68 #define _SYS_VNODE_IF_H_
  69
  70 #include <sys/appleapiopts.h>
  71
  72 #ifdef __APPLE_API_UNSTABLE
  73 extern struct vnodeop_desc vop_default_desc;
  74
  75
  76 struct vop_lookup_args {
  77         struct vnodeop_desc *a_desc;
  78         struct vnode *a_dvp;
  79         struct vnode **a_vpp;
  80         struct componentname *a_cnp;
  81 };
  82 extern struct vnodeop_desc vop_lookup_desc;
  83 #define VOP_LOOKUP(dvp, vpp, cnp) _VOP_LOOKUP(dvp, vpp, cnp)
  84 static __inline int _VOP_LOOKUP(struct vnode *dvp, struct vnode **vpp, struct componentname *cnp)
  85 {
  86         struct vop_lookup_args a;
  87         a.a_desc = VDESC(vop_lookup);
  88         a.a_dvp = dvp;
  89         a.a_vpp = vpp;
  90         a.a_cnp = cnp;
  91         return (VCALL(dvp, VOFFSET(vop_lookup), &a));
  92 }
  93
  94 struct vop_cachedlookup_args {
  95         struct vnodeop_desc *a_desc;
  96         struct vnode *a_dvp;
  97         struct vnode **a_vpp;
  98         struct componentname *a_cnp;
  99 };
 100 extern struct vnodeop_desc vop_cachedlookup_desc;
 101 #define VOP_CACHEDLOOKUP(dvp, vpp, cnp) _VOP_CACHEDLOOKUP(dvp, vpp, cnp)
 102 static __inline int _VOP_CACHEDLOOKUP(struct vnode *dvp, struct vnode **vpp, struct componentname *cnp)
 103 {
 104         struct vop_cachedlookup_args a;
 105         a.a_desc = VDESC(vop_cachedlookup);
 106         a.a_dvp = dvp;
 107         a.a_vpp = vpp;
 108         a.a_cnp = cnp;
 109         return (VCALL(dvp, VOFFSET(vop_cachedlookup), &a));
 110 }
 111
 112 struct vop_create_args {
 113         struct vnodeop_desc *a_desc;
 114         struct vnode *a_dvp;
 115         struct vnode **a_vpp;
 116         struct componentname *a_cnp;
 117         struct vattr *a_vap;
 118 };
 119 extern struct vnodeop_desc vop_create_desc;
 120 #define VOP_CREATE(dvp, vpp, cnp, vap) _VOP_CREATE(dvp, vpp, cnp, vap)
 121 static __inline int _VOP_CREATE(struct vnode *dvp, struct vnode **vpp, struct componentname *cnp, struct vattr *vap)
 122 {
 123         struct vop_create_args a;
 124         a.a_desc = VDESC(vop_create);
 125         a.a_dvp = dvp;
 126         a.a_vpp = vpp;
 127         a.a_cnp = cnp;
 128         a.a_vap = vap;
 129         return (VCALL(dvp, VOFFSET(vop_create), &a));
 130 }
 131
 132 struct vop_whiteout_args {
 133         struct vnodeop_desc *a_desc;
 134         struct vnode *a_dvp;
 135         struct componentname *a_cnp;
 136         int a_flags;
 137 };
 138 extern struct vnodeop_desc vop_whiteout_desc;
 139 #define VOP_WHITEOUT(dvp, cnp, flags) _VOP_WHITEOUT(dvp, cnp, flags)
 140 static __inline int _VOP_WHITEOUT(struct vnode *dvp, struct componentname *cnp, int flags)
 141 {
 142         struct vop_whiteout_args a;
 143         a.a_desc = VDESC(vop_whiteout);
 144         a.a_dvp = dvp;
 145         a.a_cnp = cnp;
 146         a.a_flags = flags;
 147         return (VCALL(dvp, VOFFSET(vop_whiteout), &a));
 148 }
 149
 150 struct vop_mknod_args {
 151         struct vnodeop_desc *a_desc;
 152         struct vnode *a_dvp;
 153         struct vnode **a_vpp;
 154         struct componentname *a_cnp;
 155         struct vattr *a_vap;
 156 };
 157 extern struct vnodeop_desc vop_mknod_desc;
 158 #define VOP_MKNOD(dvp, vpp, cnp, vap) _VOP_MKNOD(dvp, vpp, cnp, vap)
 159 static __inline int _VOP_MKNOD(struct vnode *dvp, struct vnode **vpp, struct componentname *cnp, struct vattr *vap)
 160 {
 161         struct vop_mknod_args a;
 162         a.a_desc = VDESC(vop_mknod);
 163         a.a_dvp = dvp;
 164         a.a_vpp = vpp;
 165         a.a_cnp = cnp;
 166         a.a_vap = vap;
 167         return (VCALL(dvp, VOFFSET(vop_mknod), &a));
 168 }
 169
 170 struct vop_mkcomplex_args {
 171         struct vnodeop_desc *a_desc;
 172         struct vnode *a_dvp;
 173         struct vnode **a_vpp;
 174         struct componentname *a_cnp;
 175         struct vattr *a_vap;
 176         u_long a_type;
 177 };
 178 extern struct vnodeop_desc vop_mkcomplex_desc;
 179 #define VOP_MKCOMPLEX(dvp, vpp, cnp, vap, type) _VOP_MKCOMPLEX(dvp, vpp, cnp, vap, type)
 180 static __inline int _VOP_MKCOMPLEX(struct vnode *dvp, struct vnode **vpp, struct componentname *cnp, struct vattr *vap, u_long type)
 181 {
 182         struct vop_mkcomplex_args a;
 183         a.a_desc = VDESC(vop_mkcomplex);
 184         a.a_dvp = dvp;
 185         a.a_vpp = vpp;
 186         a.a_cnp = cnp;
 187         a.a_vap = vap;
 188         a.a_type = type;
 189         return (VCALL(dvp, VOFFSET(vop_mkcomplex), &a));
 190 }
 191
 192 struct vop_open_args {
 193         struct vnodeop_desc *a_desc;
 194         struct vnode *a_vp;
 195         int a_mode;
 196         struct ucred *a_cred;
 197         struct proc *a_p;
 198 };
 199 extern struct vnodeop_desc vop_open_desc;
 200 #define VOP_OPEN(vp, mode, cred, p) _VOP_OPEN(vp, mode, cred, p)
 201 static __inline int _VOP_OPEN(struct vnode *vp, int mode, struct ucred *cred, struct proc *p)
 202 {
 203         struct vop_open_args a;
 204         a.a_desc = VDESC(vop_open);
 205         a.a_vp = vp;
 206         a.a_mode = mode;
 207         a.a_cred = cred;
 208         a.a_p = p;
 209         return (VCALL(vp, VOFFSET(vop_open), &a));
 210 }
 211
 212 struct vop_close_args {
 213         struct vnodeop_desc *a_desc;
 214         struct vnode *a_vp;
 215         int a_fflag;
 216         struct ucred *a_cred;
 217         struct proc *a_p;
 218 };
 219 extern struct vnodeop_desc vop_close_desc;
 220 #define VOP_CLOSE(vp, fflag, cred, p) _VOP_CLOSE(vp, fflag, cred, p)
 221 static __inline int _VOP_CLOSE(struct vnode *vp, int fflag, struct ucred *cred, struct proc *p)
 222 {
 223         struct vop_close_args a;
 224         a.a_desc = VDESC(vop_close);
 225         a.a_vp = vp;
 226         a.a_fflag = fflag;
 227         a.a_cred = cred;
 228         a.a_p = p;
 229         return (VCALL(vp, VOFFSET(vop_close), &a));
 230 }
 231
 232 struct vop_access_args {
 233         struct vnodeop_desc *a_desc;
 234         struct vnode *a_vp;
 235         int a_mode;
 236         struct ucred *a_cred;
 237         struct proc *a_p;
 238 };
 239 extern struct vnodeop_desc vop_access_desc;
 240 #define VOP_ACCESS(vp, mode, cred, p) _VOP_ACCESS(vp, mode, cred, p)
 241 static __inline int _VOP_ACCESS(struct vnode *vp, int mode, struct ucred *cred, struct proc *p)
 242 {
 243         struct vop_access_args a;
 244         a.a_desc = VDESC(vop_access);
 245         a.a_vp = vp;
 246         a.a_mode = mode;
 247         a.a_cred = cred;
 248         a.a_p = p;
 249         return (VCALL(vp, VOFFSET(vop_access), &a));
 250 }
 251
 252 struct vop_getattr_args {
 253         struct vnodeop_desc *a_desc;
 254         struct vnode *a_vp;
 255         struct vattr *a_vap;
 256         struct ucred *a_cred;
 257         struct proc *a_p;
 258 };
 259 extern struct vnodeop_desc vop_getattr_desc;
 260 #define VOP_GETATTR(vp, vap, cred, p) _VOP_GETATTR(vp, vap, cred, p)
 261 static __inline int _VOP_GETATTR(struct vnode *vp, struct vattr *vap, struct ucred *cred, struct proc *p)
 262 {
 263         struct vop_getattr_args a;
 264         a.a_desc = VDESC(vop_getattr);
 265         a.a_vp = vp;
 266         a.a_vap = vap;
 267         a.a_cred = cred;
 268         a.a_p = p;
 269         return (VCALL(vp, VOFFSET(vop_getattr), &a));
 270 }
 271
 272 struct vop_setattr_args {
 273         struct vnodeop_desc *a_desc;
 274         struct vnode *a_vp;
 275         struct vattr *a_vap;
 276         struct ucred *a_cred;
 277         struct proc *a_p;
 278 };
 279 extern struct vnodeop_desc vop_setattr_desc;
 280 #define VOP_SETATTR(vp, vap, cred, p) _VOP_SETATTR(vp, vap, cred, p)
 281 static __inline int _VOP_SETATTR(struct vnode *vp, struct vattr *vap, struct ucred *cred, struct proc *p)
 282 {
 283         struct vop_setattr_args a;
 284         a.a_desc = VDESC(vop_setattr);
 285         a.a_vp = vp;
 286         a.a_vap = vap;
 287         a.a_cred = cred;
 288         a.a_p = p;
 289         return (VCALL(vp, VOFFSET(vop_setattr), &a));
 290 }
 291
 292 struct vop_getattrlist_args {
 293         struct vnodeop_desc *a_desc;
 294         struct vnode *a_vp;
 295         struct attrlist *a_alist;
 296         struct uio *a_uio;
 297         struct ucred *a_cred;
 298         struct proc *a_p;
 299 };
 300 extern struct vnodeop_desc vop_getattrlist_desc;
 301 #define VOP_GETATTRLIST(vp, alist, uio, cred, p) _VOP_GETATTRLIST(vp, alist, uio, cred, p)
 302 static __inline int _VOP_GETATTRLIST(struct vnode *vp, struct attrlist *alist, struct uio *uio, struct ucred *cred, struct proc *p)
 303 {
 304         struct vop_getattrlist_args a;
 305         a.a_desc = VDESC(vop_getattrlist);
 306         a.a_vp = vp;
 307         a.a_alist = alist;
 308         a.a_uio = uio;
 309         a.a_cred = cred;
 310         a.a_p = p;
 311         return (VCALL(vp, VOFFSET(vop_getattrlist), &a));
 312 }
 313
 314 struct vop_setattrlist_args {
 315         struct vnodeop_desc *a_desc;
 316         struct vnode *a_vp;
 317         struct attrlist *a_alist;
 318         struct uio *a_uio;
 319         struct ucred *a_cred;
 320         struct proc *a_p;
 321 };
 322 extern struct vnodeop_desc vop_setattrlist_desc;
 323 #define VOP_SETATTRLIST(vp, alist, uio, cred, p) _VOP_SETATTRLIST(vp, alist, uio, cred, p)
 324 static __inline int _VOP_SETATTRLIST(struct vnode *vp, struct attrlist *alist, struct uio *uio, struct ucred *cred, struct proc *p)
 325 {
 326         struct vop_setattrlist_args a;
 327         a.a_desc = VDESC(vop_setattrlist);
 328         a.a_vp = vp;
 329         a.a_alist = alist;
 330         a.a_uio = uio;
 331         a.a_cred = cred;
 332         a.a_p = p;
 333         return (VCALL(vp, VOFFSET(vop_setattrlist), &a));
 334 }
 335
 336 struct vop_read_args {
 337         struct vnodeop_desc *a_desc;
 338         struct vnode *a_vp;
 339         struct uio *a_uio;
 340         int a_ioflag;
 341         struct ucred *a_cred;
 342 };
 343 extern struct vnodeop_desc vop_read_desc;
 344 #define VOP_READ(vp, uio, ioflag, cred) _VOP_READ(vp, uio, ioflag, cred)
 345 static __inline int _VOP_READ(struct vnode *vp, struct uio *uio, int ioflag, struct ucred *cred)
 346 {
 347         struct vop_read_args a;
 348         a.a_desc = VDESC(vop_read);
 349         a.a_vp = vp;
 350         a.a_uio = uio;
 351         a.a_ioflag = ioflag;
 352         a.a_cred = cred;
 353         {
 354                 int _err;
 355                 extern int ubc_hold(struct vnode *vp);
 356                 extern void ubc_rele(struct vnode *vp);
 357                 int _didhold = ubc_hold(vp);
 358                 _err = VCALL(vp, VOFFSET(vop_read), &a);
 359                 if (_didhold)
 360                         ubc_rele(vp);
 361                 return (_err);
 362         }
 363 }
 364
 365 struct vop_write_args {
 366         struct vnodeop_desc *a_desc;
 367         struct vnode *a_vp;
 368         struct uio *a_uio;
 369         int a_ioflag;
 370         struct ucred *a_cred;
 371 };
 372 extern struct vnodeop_desc vop_write_desc;
 373 #define VOP_WRITE(vp, uio, ioflag, cred) _VOP_WRITE(vp, uio, ioflag, cred)
 374 static __inline int _VOP_WRITE(struct vnode *vp, struct uio *uio, int ioflag, 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         {
 383                 int _err;
 384                 extern int ubc_hold(struct vnode *vp);
 385                 extern void ubc_rele(struct vnode *vp);
 386                 int _didhold = ubc_hold(vp);
 387                 _err = VCALL(vp, VOFFSET(vop_write), &a);
 388                 if (_didhold)
 389                         ubc_rele(vp);
 390                 return (_err);
 391         }
 392 }
 393
 394 struct vop_lease_args {
 395         struct vnodeop_desc *a_desc;
 396         struct vnode *a_vp;
 397         struct proc *a_p;
 398         struct ucred *a_cred;
 399         int a_flag;
 400 };
 401 extern struct vnodeop_desc vop_lease_desc;
 402 #define VOP_LEASE(vp, p, cred, flag) _VOP_LEASE(vp, p, cred, flag)
 403 static __inline int _VOP_LEASE(struct vnode *vp, struct proc *p, struct ucred *cred, int flag)
 404 {
 405         struct vop_lease_args a;
 406         a.a_desc = VDESC(vop_lease);
 407         a.a_vp = vp;
 408         a.a_p = p;
 409         a.a_cred = cred;
 410         a.a_flag = flag;
 411         return (VCALL(vp, VOFFSET(vop_lease), &a));
 412 }
 413
 414 struct vop_ioctl_args {
 415         struct vnodeop_desc *a_desc;
 416         struct vnode *a_vp;
 417         u_long a_command;
 418         caddr_t a_data;
 419         int a_fflag;
 420         struct ucred *a_cred;
 421         struct proc *a_p;
 422 };
 423 extern struct vnodeop_desc vop_ioctl_desc;
 424 #define VOP_IOCTL(vp, command, data, fflag, cred, p) _VOP_IOCTL(vp, command, data, fflag, cred, p)
 425 static __inline int _VOP_IOCTL(struct vnode *vp, u_long command, caddr_t data, int fflag, struct ucred *cred, struct proc *p)
 426 {
 427         struct vop_ioctl_args a;
 428         a.a_desc = VDESC(vop_ioctl);
 429         a.a_vp = vp;
 430         a.a_command = command;
 431         a.a_data = data;
 432         a.a_fflag = fflag;
 433         a.a_cred = cred;
 434         a.a_p = p;
 435         return (VCALL(vp, VOFFSET(vop_ioctl), &a));
 436 }
 437
 438 struct vop_select_args {
 439         struct vnodeop_desc *a_desc;
 440         struct vnode *a_vp;
 441         int a_which;
 442         int a_fflags;
 443         struct ucred *a_cred;
 444         void *a_wql;
 445         struct proc *a_p;
 446 };
 447 extern struct vnodeop_desc vop_select_desc;
 448 #define VOP_SELECT(vp, which, fflags, cred, wql, p) _VOP_SELECT(vp, which, fflags, cred, wql, p)
 449 static __inline int _VOP_SELECT(struct vnode *vp, int which, int fflags, struct ucred *cred, void *wql, struct proc *p)
 450 {
 451         struct vop_select_args a;
 452         a.a_desc = VDESC(vop_select);
 453         a.a_vp = vp;
 454         a.a_which = which;
 455         a.a_fflags = fflags;
 456         a.a_cred = cred;
 457         a.a_wql = wql;
 458         a.a_p = p;
 459         return (VCALL(vp, VOFFSET(vop_select), &a));
 460 }
 461
 462 struct vop_exchange_args {
 463         struct vnodeop_desc *a_desc;
 464         struct vnode *a_fvp;
 465         struct vnode *a_tvp;
 466         struct ucred *a_cred;
 467         struct proc *a_p;
 468 };
 469 extern struct vnodeop_desc vop_exchange_desc;
 470 #define VOP_EXCHANGE(fvp, tvp, cred, p) _VOP_EXCHANGE(fvp, tvp, cred, p)
 471 static __inline int _VOP_EXCHANGE(struct vnode *fvp, struct vnode *tvp, struct ucred *cred, struct proc *p)
 472 {
 473         struct vop_exchange_args a;
 474         a.a_desc = VDESC(vop_exchange);
 475         a.a_fvp = fvp;
 476         a.a_tvp = tvp;
 477         a.a_cred = cred;
 478         a.a_p = p;
 479         return (VCALL(fvp, VOFFSET(vop_exchange), &a));
 480 }
 481
 482 struct vop_revoke_args {
 483         struct vnodeop_desc *a_desc;
 484         struct vnode *a_vp;
 485         int a_flags;
 486 };
 487 extern struct vnodeop_desc vop_revoke_desc;
 488 #define VOP_REVOKE(vp, flags) _VOP_REVOKE(vp, flags)
 489 static __inline int _VOP_REVOKE(struct vnode *vp, int flags)
 490 {
 491         struct vop_revoke_args a;
 492         a.a_desc = VDESC(vop_revoke);
 493         a.a_vp = vp;
 494         a.a_flags = flags;
 495         return (VCALL(vp, VOFFSET(vop_revoke), &a));
 496 }
 497
 498 struct vop_mmap_args {
 499         struct vnodeop_desc *a_desc;
 500         struct vnode *a_vp;
 501         int a_fflags;
 502         struct ucred *a_cred;
 503         struct proc *a_p;
 504 };
 505 extern struct vnodeop_desc vop_mmap_desc;
 506 #define VOP_MMAP(vp, fflags, cred, p) _VOP_MMAP(vp, fflags, cred, p)
 507 static __inline int _VOP_MMAP(struct vnode *vp, int fflags, struct ucred *cred, struct proc *p)
 508 {
 509         struct vop_mmap_args a;
 510         a.a_desc = VDESC(vop_mmap);
 511         a.a_vp = vp;
 512         a.a_fflags = fflags;
 513         a.a_cred = cred;
 514         a.a_p = p;
 515         return (VCALL(vp, VOFFSET(vop_mmap), &a));
 516 }
 517
 518 struct vop_fsync_args {
 519         struct vnodeop_desc *a_desc;
 520         struct vnode *a_vp;
 521         struct ucred *a_cred;
 522         int a_waitfor;
 523         struct proc *a_p;
 524 };
 525 extern struct vnodeop_desc vop_fsync_desc;
 526 #define VOP_FSYNC(vp, cred, waitfor, p) _VOP_FSYNC(vp, cred, waitfor, p)
 527 static __inline int _VOP_FSYNC(struct vnode *vp, struct ucred *cred, int waitfor, struct proc *p)
 528 {
 529         struct vop_fsync_args a;
 530         a.a_desc = VDESC(vop_fsync);
 531         a.a_vp = vp;
 532         a.a_cred = cred;
 533         a.a_waitfor = waitfor;
 534         a.a_p = p;
 535         {
 536                 int _err;
 537                 extern int ubc_hold(struct vnode *vp);
 538                 extern void ubc_rele(struct vnode *vp);
 539                 int _didhold = ubc_hold(vp);
 540                 _err = VCALL(vp, VOFFSET(vop_fsync), &a);
 541                 if (_didhold)
 542                         ubc_rele(vp);
 543                 return (_err);
 544         }
 545 }
 546
 547 struct vop_seek_args {
 548         struct vnodeop_desc *a_desc;
 549         struct vnode *a_vp;
 550         off_t a_oldoff;
 551         off_t a_newoff;
 552         struct ucred *a_cred;
 553 };
 554 extern struct vnodeop_desc vop_seek_desc;
 555 #define VOP_SEEK(vp, oldoff, newoff, cred) _VOP_SEEK(vp, oldoff, newoff, cred)
 556 static __inline int _VOP_SEEK(struct vnode *vp, off_t oldoff, off_t newoff, struct ucred *cred)
 557 {
 558         struct vop_seek_args a;
 559         a.a_desc = VDESC(vop_seek);
 560         a.a_vp = vp;
 561         a.a_oldoff = oldoff;
 562         a.a_newoff = newoff;
 563         a.a_cred = cred;
 564         return (VCALL(vp, VOFFSET(vop_seek), &a));
 565 }
 566
 567 struct vop_remove_args {
 568         struct vnodeop_desc *a_desc;
 569         struct vnode *a_dvp;
 570         struct vnode *a_vp;
 571         struct componentname *a_cnp;
 572 };
 573 extern struct vnodeop_desc vop_remove_desc;
 574 #define VOP_REMOVE(dvp, vp, cnp) _VOP_REMOVE(dvp, vp, cnp)
 575 static __inline int _VOP_REMOVE(struct vnode *dvp, struct vnode *vp, struct componentname *cnp)
 576 {
 577         struct vop_remove_args a;
 578         a.a_desc = VDESC(vop_remove);
 579         a.a_dvp = dvp;
 580         a.a_vp = vp;
 581         a.a_cnp = cnp;
 582         return (VCALL(dvp, VOFFSET(vop_remove), &a));
 583 }
 584
 585 struct vop_link_args {
 586         struct vnodeop_desc *a_desc;
 587         struct vnode *a_vp;
 588         struct vnode *a_tdvp;
 589         struct componentname *a_cnp;
 590 };
 591 extern struct vnodeop_desc vop_link_desc;
 592 #define VOP_LINK(vp, tdvp, cnp) _VOP_LINK(vp, tdvp, cnp)
 593 static __inline int _VOP_LINK(struct vnode *vp, struct vnode *tdvp, struct componentname *cnp)
 594 {
 595         struct vop_link_args a;
 596         a.a_desc = VDESC(vop_link);
 597         a.a_vp = vp;
 598         a.a_tdvp = tdvp;
 599         a.a_cnp = cnp;
 600         return (VCALL(vp, VOFFSET(vop_link), &a));
 601 }
 602
 603 struct vop_rename_args {
 604         struct vnodeop_desc *a_desc;
 605         struct vnode *a_fdvp;
 606         struct vnode *a_fvp;
 607         struct componentname *a_fcnp;
 608         struct vnode *a_tdvp;
 609         struct vnode *a_tvp;
 610         struct componentname *a_tcnp;
 611 };
 612 extern struct vnodeop_desc vop_rename_desc;
 613 #define VOP_RENAME(fdvp, fvp, fcnp, tdvp, tvp, tcnp) _VOP_RENAME(fdvp, fvp, fcnp, tdvp, tvp, tcnp)
 614 static __inline int _VOP_RENAME(struct vnode *fdvp, struct vnode *fvp, struct componentname *fcnp, struct vnode *tdvp, struct vnode *tvp, struct componentname *tcnp)
 615 {
 616         struct vop_rename_args a;
 617         a.a_desc = VDESC(vop_rename);
 618         a.a_fdvp = fdvp;
 619         a.a_fvp = fvp;
 620         a.a_fcnp = fcnp;
 621         a.a_tdvp = tdvp;
 622         a.a_tvp = tvp;
 623         a.a_tcnp = tcnp;
 624         return (VCALL(fdvp, VOFFSET(vop_rename), &a));
 625 }
 626
 627 struct vop_mkdir_args {
 628         struct vnodeop_desc *a_desc;
 629         struct vnode *a_dvp;
 630         struct vnode **a_vpp;
 631         struct componentname *a_cnp;
 632         struct vattr *a_vap;
 633 };
 634 extern struct vnodeop_desc vop_mkdir_desc;
 635 #define VOP_MKDIR(dvp, vpp, cnp, vap) _VOP_MKDIR(dvp, vpp, cnp, vap)
 636 static __inline int _VOP_MKDIR(struct vnode *dvp, struct vnode **vpp, struct componentname *cnp, struct vattr *vap)
 637 {
 638         struct vop_mkdir_args a;
 639         a.a_desc = VDESC(vop_mkdir);
 640         a.a_dvp = dvp;
 641         a.a_vpp = vpp;
 642         a.a_cnp = cnp;
 643         a.a_vap = vap;
 644         return (VCALL(dvp, VOFFSET(vop_mkdir), &a));
 645 }
 646
 647 struct vop_rmdir_args {
 648         struct vnodeop_desc *a_desc;
 649         struct vnode *a_dvp;
 650         struct vnode *a_vp;
 651         struct componentname *a_cnp;
 652 };
 653 extern struct vnodeop_desc vop_rmdir_desc;
 654 #define VOP_RMDIR(dvp, vp, cnp) _VOP_RMDIR(dvp, vp, cnp)
 655 static __inline int _VOP_RMDIR(struct vnode *dvp, struct vnode *vp, struct componentname *cnp)
 656 {
 657         struct vop_rmdir_args a;
 658         a.a_desc = VDESC(vop_rmdir);
 659         a.a_dvp = dvp;
 660         a.a_vp = vp;
 661         a.a_cnp = cnp;
 662         return (VCALL(dvp, VOFFSET(vop_rmdir), &a));
 663 }
 664
 665 struct vop_symlink_args {
 666         struct vnodeop_desc *a_desc;
 667         struct vnode *a_dvp;
 668         struct vnode **a_vpp;
 669         struct componentname *a_cnp;
 670         struct vattr *a_vap;
 671         char *a_target;
 672 };
 673 extern struct vnodeop_desc vop_symlink_desc;
 674 #define VOP_SYMLINK(dvp, vpp, cnp, vap, target) _VOP_SYMLINK(dvp, vpp, cnp, vap, target)
 675 static __inline int _VOP_SYMLINK(struct vnode *dvp, struct vnode **vpp, struct componentname *cnp, struct vattr *vap, char *target)
 676 {
 677         struct vop_symlink_args a;
 678         a.a_desc = VDESC(vop_symlink);
 679         a.a_dvp = dvp;
 680         a.a_vpp = vpp;
 681         a.a_cnp = cnp;
 682         a.a_vap = vap;
 683         a.a_target = target;
 684         return (VCALL(dvp, VOFFSET(vop_symlink), &a));
 685 }
 686
 687 struct vop_readdir_args {
 688         struct vnodeop_desc *a_desc;
 689         struct vnode *a_vp;
 690         struct uio *a_uio;
 691         struct ucred *a_cred;
 692         int *a_eofflag;
 693         int *a_ncookies;
 694         u_long **a_cookies;
 695 };
 696 extern struct vnodeop_desc vop_readdir_desc;
 697 #define VOP_READDIR(vp, uio, cred, eofflag, ncookies, cookies) _VOP_READDIR(vp, uio, cred, eofflag, ncookies, cookies)
 698 static __inline int _VOP_READDIR(struct vnode *vp, struct uio *uio, struct ucred *cred, int *eofflag, int *ncookies, u_long **cookies)
 699 {
 700         struct vop_readdir_args a;
 701         a.a_desc = VDESC(vop_readdir);
 702         a.a_vp = vp;
 703         a.a_uio = uio;
 704         a.a_cred = cred;
 705         a.a_eofflag = eofflag;
 706         a.a_ncookies = ncookies;
 707         a.a_cookies = cookies;
 708         return (VCALL(vp, VOFFSET(vop_readdir), &a));
 709 }
 710
 711 struct vop_readdirattr_args {
 712         struct vnodeop_desc *a_desc;
 713         struct vnode *a_vp;
 714         struct attrlist *a_alist;
 715         struct uio *a_uio;
 716         u_long a_maxcount;
 717         u_long a_options;
 718         u_long *a_newstate;
 719         int *a_eofflag;
 720         u_long *a_actualcount;
 721         u_long **a_cookies;
 722         struct ucred *a_cred;
 723 };
 724 extern struct vnodeop_desc vop_readdirattr_desc;
 725 #define VOP_READDIRATTR(vp, alist, uio, maxcount, options, newstate, eofflag, actualcount, cookies, cred) _VOP_READDIRATTR(vp, alist, uio, maxcount, options, newstate, eofflag, actualcount, cookies, cred)
 726 static __inline int _VOP_READDIRATTR(struct vnode *vp, struct attrlist *alist, struct uio *uio, u_long maxcount, u_long options, u_long *newstate, int *eofflag, u_long *actualcount, u_long **cookies, struct ucred *cred)
 727 {
 728         struct vop_readdirattr_args a;
 729         a.a_desc = VDESC(vop_readdirattr);
 730         a.a_vp = vp;
 731         a.a_alist = alist;
 732         a.a_uio = uio;
 733         a.a_maxcount = maxcount;
 734         a.a_options = options;
 735         a.a_newstate = newstate;
 736         a.a_eofflag = eofflag;
 737         a.a_actualcount = actualcount;
 738         a.a_cookies = cookies;
 739         a.a_cred = cred;
 740         return (VCALL(vp, VOFFSET(vop_readdirattr), &a));
 741 }
 742
 743 struct vop_readlink_args {
 744         struct vnodeop_desc *a_desc;
 745         struct vnode *a_vp;
 746         struct uio *a_uio;
 747         struct ucred *a_cred;
 748 };
 749 extern struct vnodeop_desc vop_readlink_desc;
 750 #define VOP_READLINK(vp, uio, cred) _VOP_READLINK(vp, uio, cred)
 751 static __inline int _VOP_READLINK(struct vnode *vp, struct uio *uio, struct ucred *cred)
 752 {
 753         struct vop_readlink_args a;
 754         a.a_desc = VDESC(vop_readlink);
 755         a.a_vp = vp;
 756         a.a_uio = uio;
 757         a.a_cred = cred;
 758         return (VCALL(vp, VOFFSET(vop_readlink), &a));
 759 }
 760
 761 struct vop_abortop_args {
 762         struct vnodeop_desc *a_desc;
 763         struct vnode *a_dvp;
 764         struct componentname *a_cnp;
 765 };
 766 extern struct vnodeop_desc vop_abortop_desc;
 767 #define VOP_ABORTOP(dvp, cnp) _VOP_ABORTOP(dvp, cnp)
 768 static __inline int _VOP_ABORTOP(struct vnode *dvp, struct componentname *cnp)
 769 {
 770         struct vop_abortop_args a;
 771         a.a_desc = VDESC(vop_abortop);
 772         a.a_dvp = dvp;
 773         a.a_cnp = cnp;
 774         return (VCALL(dvp, VOFFSET(vop_abortop), &a));
 775 }
 776
 777 struct vop_inactive_args {
 778         struct vnodeop_desc *a_desc;
 779         struct vnode *a_vp;
 780         struct proc *a_p;
 781 };
 782 extern struct vnodeop_desc vop_inactive_desc;
 783 #define VOP_INACTIVE(vp, p) _VOP_INACTIVE(vp, p)
 784 static __inline int _VOP_INACTIVE(struct vnode *vp, struct proc *p)
 785 {
 786         struct vop_inactive_args a;
 787         a.a_desc = VDESC(vop_inactive);
 788         a.a_vp = vp;
 789         a.a_p = p;
 790         return (VCALL(vp, VOFFSET(vop_inactive), &a));
 791 }
 792
 793 struct vop_reclaim_args {
 794         struct vnodeop_desc *a_desc;
 795         struct vnode *a_vp;
 796         struct proc *a_p;
 797 };
 798 extern struct vnodeop_desc vop_reclaim_desc;
 799 #define VOP_RECLAIM(vp, p) _VOP_RECLAIM(vp, p)
 800 static __inline int _VOP_RECLAIM(struct vnode *vp, struct proc *p)
 801 {
 802         struct vop_reclaim_args a;
 803         a.a_desc = VDESC(vop_reclaim);
 804         a.a_vp = vp;
 805         a.a_p = p;
 806         return (VCALL(vp, VOFFSET(vop_reclaim), &a));
 807 }
 808
 809 struct vop_lock_args {
 810         struct vnodeop_desc *a_desc;
 811         struct vnode *a_vp;
 812         int a_flags;
 813         struct proc *a_p;
 814 };
 815 extern struct vnodeop_desc vop_lock_desc;
 816 #define VOP_LOCK(vp, flags, p) _VOP_LOCK(vp, flags, p)
 817 static __inline int _VOP_LOCK(struct vnode *vp, int flags, struct proc *p)
 818 {
 819         struct vop_lock_args a;
 820         a.a_desc = VDESC(vop_lock);
 821         a.a_vp = vp;
 822         a.a_flags = flags;
 823         a.a_p = p;
 824         return (VCALL(vp, VOFFSET(vop_lock), &a));
 825 }
 826
 827 struct vop_unlock_args {
 828         struct vnodeop_desc *a_desc;
 829         struct vnode *a_vp;
 830         int a_flags;
 831         struct proc *a_p;
 832 };
 833 extern struct vnodeop_desc vop_unlock_desc;
 834 #define VOP_UNLOCK(vp, flags, p) _VOP_UNLOCK(vp, flags, p)
 835 static __inline int _VOP_UNLOCK(struct vnode *vp, int flags, struct proc *p)
 836 {
 837         struct vop_unlock_args a;
 838         a.a_desc = VDESC(vop_unlock);
 839         a.a_vp = vp;
 840         a.a_flags = flags;
 841         a.a_p = p;
 842         return (VCALL(vp, VOFFSET(vop_unlock), &a));
 843 }
 844
 845 struct vop_bmap_args {
 846         struct vnodeop_desc *a_desc;
 847         struct vnode *a_vp;
 848         daddr_t a_bn;
 849         struct vnode **a_vpp;
 850         daddr_t *a_bnp;
 851         int *a_runp;
 852 };
 853 extern struct vnodeop_desc vop_bmap_desc;
 854 #define VOP_BMAP(vp, bn, vpp, bnp, runp) _VOP_BMAP(vp, bn, vpp, bnp, runp)
 855 static __inline int _VOP_BMAP(struct vnode *vp, daddr_t bn, struct vnode **vpp, daddr_t *bnp, int *runp)
 856 {
 857         struct vop_bmap_args a;
 858         a.a_desc = VDESC(vop_bmap);
 859         a.a_vp = vp;
 860         a.a_bn = bn;
 861         a.a_vpp = vpp;
 862         a.a_bnp = bnp;
 863         a.a_runp = runp;
 864         return (VCALL(vp, VOFFSET(vop_bmap), &a));
 865 }
 866
 867 struct vop_print_args {
 868         struct vnodeop_desc *a_desc;
 869         struct vnode *a_vp;
 870 };
 871 extern struct vnodeop_desc vop_print_desc;
 872 #define VOP_PRINT(vp) _VOP_PRINT(vp)
 873 static __inline int _VOP_PRINT(struct vnode *vp)
 874 {
 875         struct vop_print_args a;
 876         a.a_desc = VDESC(vop_print);
 877         a.a_vp = vp;
 878         return (VCALL(vp, VOFFSET(vop_print), &a));
 879 }
 880
 881 struct vop_islocked_args {
 882         struct vnodeop_desc *a_desc;
 883         struct vnode *a_vp;
 884 };
 885 extern struct vnodeop_desc vop_islocked_desc;
 886 #define VOP_ISLOCKED(vp) _VOP_ISLOCKED(vp)
 887 static __inline int _VOP_ISLOCKED(struct vnode *vp)
 888 {
 889         struct vop_islocked_args a;
 890         a.a_desc = VDESC(vop_islocked);
 891         a.a_vp = vp;
 892         return (VCALL(vp, VOFFSET(vop_islocked), &a));
 893 }
 894
 895 struct vop_pathconf_args {
 896         struct vnodeop_desc *a_desc;
 897         struct vnode *a_vp;
 898         int a_name;
 899         register_t *a_retval;
 900 };
 901 extern struct vnodeop_desc vop_pathconf_desc;
 902 #define VOP_PATHCONF(vp, name, retval) _VOP_PATHCONF(vp, name, retval)
 903 static __inline int _VOP_PATHCONF(struct vnode *vp, int name, register_t *retval)
 904 {
 905         struct vop_pathconf_args a;
 906         a.a_desc = VDESC(vop_pathconf);
 907         a.a_vp = vp;
 908         a.a_name = name;
 909         a.a_retval = retval;
 910         return (VCALL(vp, VOFFSET(vop_pathconf), &a));
 911 }
 912
 913 struct vop_advlock_args {
 914         struct vnodeop_desc *a_desc;
 915         struct vnode *a_vp;
 916         caddr_t a_id;
 917         int a_op;
 918         struct flock *a_fl;
 919         int a_flags;
 920 };
 921 extern struct vnodeop_desc vop_advlock_desc;
 922 #define VOP_ADVLOCK(vp, id, op, fl, flags) _VOP_ADVLOCK(vp, id, op, fl, flags)
 923 static __inline int _VOP_ADVLOCK(struct vnode *vp, caddr_t id, int op, struct flock *fl, int flags)
 924 {
 925         struct vop_advlock_args a;
 926         a.a_desc = VDESC(vop_advlock);
 927         a.a_vp = vp;
 928         a.a_id = id;
 929         a.a_op = op;
 930         a.a_fl = fl;
 931         a.a_flags = flags;
 932         return (VCALL(vp, VOFFSET(vop_advlock), &a));
 933 }
 934
 935 struct vop_blkatoff_args {
 936         struct vnodeop_desc *a_desc;
 937         struct vnode *a_vp;
 938         off_t a_offset;
 939         char **a_res;
 940         struct buf **a_bpp;
 941 };
 942 extern struct vnodeop_desc vop_blkatoff_desc;
 943 #define VOP_BLKATOFF(vp, offset, res, bpp) _VOP_BLKATOFF(vp, offset, res, bpp)
 944 static __inline int _VOP_BLKATOFF(struct vnode *vp, off_t offset, char **res, struct buf **bpp)
 945 {
 946         struct vop_blkatoff_args a;
 947         a.a_desc = VDESC(vop_blkatoff);
 948         a.a_vp = vp;
 949         a.a_offset = offset;
 950         a.a_res = res;
 951         a.a_bpp = bpp;
 952         return (VCALL(vp, VOFFSET(vop_blkatoff), &a));
 953 }
 954
 955 struct vop_valloc_args {
 956         struct vnodeop_desc *a_desc;
 957         struct vnode *a_pvp;
 958         int a_mode;
 959         struct ucred *a_cred;
 960         struct vnode **a_vpp;
 961 };
 962 extern struct vnodeop_desc vop_valloc_desc;
 963 #define VOP_VALLOC(pvp, mode, cred, vpp) _VOP_VALLOC(pvp, mode, cred, vpp)
 964 static __inline int _VOP_VALLOC(struct vnode *pvp, int mode, struct ucred *cred, struct vnode **vpp)
 965 {
 966         struct vop_valloc_args a;
 967         a.a_desc = VDESC(vop_valloc);
 968         a.a_pvp = pvp;
 969         a.a_mode = mode;
 970         a.a_cred = cred;
 971         a.a_vpp = vpp;
 972         return (VCALL(pvp, VOFFSET(vop_valloc), &a));
 973 }
 974
 975 struct vop_reallocblks_args {
 976         struct vnodeop_desc *a_desc;
 977         struct vnode *a_vp;
 978         struct cluster_save *a_buflist;
 979 };
 980 extern struct vnodeop_desc vop_reallocblks_desc;
 981 #define VOP_REALLOCBLKS(vp, buflist) _VOP_REALLOCBLKS(vp, buflist)
 982 static __inline int _VOP_REALLOCBLKS(struct vnode *vp, struct cluster_save *buflist)
 983 {
 984         struct vop_reallocblks_args a;
 985         a.a_desc = VDESC(vop_reallocblks);
 986         a.a_vp = vp;
 987         a.a_buflist = buflist;
 988         return (VCALL(vp, VOFFSET(vop_reallocblks), &a));
 989 }
 990
 991 struct vop_vfree_args {
 992         struct vnodeop_desc *a_desc;
 993         struct vnode *a_pvp;
 994         ino_t a_ino;
 995         int a_mode;
 996 };
 997 extern struct vnodeop_desc vop_vfree_desc;
 998 #define VOP_VFREE(pvp, ino, mode) _VOP_VFREE(pvp, ino, mode)
 999 static __inline int _VOP_VFREE(struct vnode *pvp, ino_t ino, int mode)
1000 {
1001         struct vop_vfree_args a;
1002         a.a_desc = VDESC(vop_vfree);
1003         a.a_pvp = pvp;
1004         a.a_ino = ino;
1005         a.a_mode = mode;
1006         return (VCALL(pvp, VOFFSET(vop_vfree), &a));
1007 }
1008
1009 struct vop_truncate_args {
1010         struct vnodeop_desc *a_desc;
1011         struct vnode *a_vp;
1012         off_t a_length;
1013         int a_flags;
1014         struct ucred *a_cred;
1015         struct proc *a_p;
1016 };
1017 extern struct vnodeop_desc vop_truncate_desc;
1018 #define VOP_TRUNCATE(vp, length, flags, cred, p) _VOP_TRUNCATE(vp, length, flags, cred, p)
1019 static __inline int _VOP_TRUNCATE(struct vnode *vp, off_t length, int flags, struct ucred *cred, struct proc *p)
1020 {
1021         struct vop_truncate_args a;
1022         a.a_desc = VDESC(vop_truncate);
1023         a.a_vp = vp;
1024         a.a_length = length;
1025         a.a_flags = flags;
1026         a.a_cred = cred;
1027         a.a_p = p;
1028         {
1029                 int _err;
1030                 extern int ubc_hold(struct vnode *vp);
1031                 extern void ubc_rele(struct vnode *vp);
1032                 int _didhold = ubc_hold(vp);
1033                 _err = VCALL(vp, VOFFSET(vop_truncate), &a);
1034                 if (_didhold)
1035                         ubc_rele(vp);
1036                 return (_err);
1037         }
1038 }
1039
1040 struct vop_allocate_args {
1041         struct vnodeop_desc *a_desc;
1042         struct vnode *a_vp;
1043         off_t a_length;
1044         u_int32_t a_flags;
1045         off_t *a_bytesallocated;
1046         off_t a_offset;
1047         struct ucred *a_cred;
1048         struct proc *a_p;
1049 };
1050 extern struct vnodeop_desc vop_allocate_desc;
1051 #define VOP_ALLOCATE(vp, length, flags, bytesallocated, offset, cred, p) _VOP_ALLOCATE(vp, length, flags, bytesallocated, offset, cred, p)
1052 static __inline int _VOP_ALLOCATE(struct vnode *vp, off_t length, u_int32_t flags, off_t *bytesallocated, off_t offset, struct ucred *cred, struct proc *p)
1053 {
1054         struct vop_allocate_args a;
1055         a.a_desc = VDESC(vop_allocate);
1056         a.a_vp = vp;
1057         a.a_length = length;
1058         a.a_flags = flags;
1059         a.a_bytesallocated = bytesallocated;
1060         a.a_offset = offset;
1061         a.a_cred = cred;
1062         a.a_p = p;
1063         return (VCALL(vp, VOFFSET(vop_allocate), &a));
1064 }
1065
1066 struct vop_update_args {
1067         struct vnodeop_desc *a_desc;
1068         struct vnode *a_vp;
1069         struct timeval *a_access;
1070         struct timeval *a_modify;
1071         int a_waitfor;
1072 };
1073 extern struct vnodeop_desc vop_update_desc;
1074 #define VOP_UPDATE(vp, access, modify, waitfor) _VOP_UPDATE(vp, access, modify, waitfor)
1075 static __inline int _VOP_UPDATE(struct vnode *vp, struct timeval *access, struct timeval *modify, int waitfor)
1076 {
1077         struct vop_update_args a;
1078         a.a_desc = VDESC(vop_update);
1079         a.a_vp = vp;
1080         a.a_access = access;
1081         a.a_modify = modify;
1082         a.a_waitfor = waitfor;
1083         return (VCALL(vp, VOFFSET(vop_update), &a));
1084 }
1085
1086 struct vop_pgrd_args {
1087         struct vnodeop_desc *a_desc;
1088         struct vnode *a_vp;
1089         struct uio *a_uio;
1090         struct ucred *a_cred;
1091 };
1092 extern struct vnodeop_desc vop_pgrd_desc;
1093 #define VOP_PGRD(vp, uio, cred) _VOP_PGRD(vp, uio, cred)
1094 static __inline int _VOP_PGRD(struct vnode *vp, struct uio *uio, struct ucred *cred)
1095 {
1096         struct vop_pgrd_args a;
1097         a.a_desc = VDESC(vop_pgrd);
1098         a.a_vp = vp;
1099         a.a_uio = uio;
1100         a.a_cred = cred;
1101         return (VCALL(vp, VOFFSET(vop_pgrd), &a));
1102 }
1103
1104 struct vop_pgwr_args {
1105         struct vnodeop_desc *a_desc;
1106         struct vnode *a_vp;
1107         struct uio *a_uio;
1108         struct ucred *a_cred;
1109         vm_offset_t a_offset;
1110 };
1111 extern struct vnodeop_desc vop_pgwr_desc;
1112 #define VOP_PGWR(vp, uio, cred, offset) _VOP_PGWR(vp, uio, cred, offset)
1113 static __inline int _VOP_PGWR(struct vnode *vp, struct uio *uio, struct ucred *cred, vm_offset_t offset)
1114 {
1115         struct vop_pgwr_args a;
1116         a.a_desc = VDESC(vop_pgwr);
1117         a.a_vp = vp;
1118         a.a_uio = uio;
1119         a.a_cred = cred;
1120         a.a_offset = offset;
1121         return (VCALL(vp, VOFFSET(vop_pgwr), &a));
1122 }
1123
1124 struct vop_pagein_args {
1125         struct vnodeop_desc *a_desc;
1126         struct vnode *a_vp;
1127         upl_t a_pl;
1128         vm_offset_t a_pl_offset;
1129         off_t a_f_offset;
1130         size_t a_size;
1131         struct ucred *a_cred;
1132         int a_flags;
1133 };
1134 extern struct vnodeop_desc vop_pagein_desc;
1135 #define VOP_PAGEIN(vp, pl, pl_offset, f_offset, size, cred, flags) _VOP_PAGEIN(vp, pl, pl_offset, f_offset, size, cred, flags)
1136 static __inline int _VOP_PAGEIN(struct vnode *vp, upl_t pl, vm_offset_t pl_offset, off_t f_offset, size_t size, struct ucred *cred, int flags)
1137 {
1138         struct vop_pagein_args a;
1139         a.a_desc = VDESC(vop_pagein);
1140         a.a_vp = vp;
1141         a.a_pl = pl;
1142         a.a_pl_offset = pl_offset;
1143         a.a_f_offset = f_offset;
1144         a.a_size = size;
1145         a.a_cred = cred;
1146         a.a_flags = flags;
1147         return (VCALL(vp, VOFFSET(vop_pagein), &a));
1148 }
1149
1150 struct vop_pageout_args {
1151         struct vnodeop_desc *a_desc;
1152         struct vnode *a_vp;
1153         upl_t a_pl;
1154         vm_offset_t a_pl_offset;
1155         off_t a_f_offset;
1156         size_t a_size;
1157         struct ucred *a_cred;
1158         int a_flags;
1159 };
1160 extern struct vnodeop_desc vop_pageout_desc;
1161 #define VOP_PAGEOUT(vp, pl, pl_offset, f_offset, size, cred, flags) _VOP_PAGEOUT(vp, pl, pl_offset, f_offset, size, cred, flags)
1162 static __inline int _VOP_PAGEOUT(struct vnode *vp, upl_t pl, vm_offset_t pl_offset, off_t f_offset, size_t size, struct ucred *cred, int flags)
1163 {
1164         struct vop_pageout_args a;
1165         a.a_desc = VDESC(vop_pageout);
1166         a.a_vp = vp;
1167         a.a_pl = pl;
1168         a.a_pl_offset = pl_offset;
1169         a.a_f_offset = f_offset;
1170         a.a_size = size;
1171         a.a_cred = cred;
1172         a.a_flags = flags;
1173         return (VCALL(vp, VOFFSET(vop_pageout), &a));
1174 }
1175
1176 struct vop_devblocksize_args {
1177         struct vnodeop_desc *a_desc;
1178         struct vnode *a_vp;
1179         register_t *a_retval;
1180 };
1181 extern struct vnodeop_desc vop_devblocksize_desc;
1182 #define VOP_DEVBLOCKSIZE(vp, retval) _VOP_DEVBLOCKSIZE(vp, retval)
1183 static __inline int _VOP_DEVBLOCKSIZE(struct vnode *vp, register_t *retval)
1184 {
1185         struct vop_devblocksize_args a;
1186         a.a_desc = VDESC(vop_devblocksize);
1187         a.a_vp = vp;
1188         a.a_retval = retval;
1189         return (VCALL(vp, VOFFSET(vop_devblocksize), &a));
1190 }
1191
1192 struct vop_searchfs_args {
1193         struct vnodeop_desc *a_desc;
1194         struct vnode *a_vp;
1195         void *a_searchparams1;
1196         void *a_searchparams2;
1197         struct attrlist *a_searchattrs;
1198         u_long a_maxmatches;
1199         struct timeval *a_timelimit;
1200         struct attrlist *a_returnattrs;
1201         u_long *a_nummatches;
1202         u_long a_scriptcode;
1203         u_long a_options;
1204         struct uio *a_uio;
1205         struct searchstate *a_searchstate;
1206 };
1207 extern struct vnodeop_desc vop_searchfs_desc;
1208 #define VOP_SEARCHFS(vp, searchparams1, searchparams2, searchattrs, maxmatches, timelimit, returnattrs, nummatches, scriptcode, options, uio, searchstate) _VOP_SEARCHFS(vp, searchparams1, searchparams2, searchattrs, maxmatches, timelimit, returnattrs, nummatches, scriptcode, options, uio, searchstate)
1209 static __inline int _VOP_SEARCHFS(struct vnode *vp, void *searchparams1, void *searchparams2, struct attrlist *searchattrs, u_long maxmatches, struct timeval *timelimit, struct attrlist *returnattrs, u_long *nummatches, u_long scriptcode, u_long options, struct uio *uio, struct searchstate *searchstate)
1210 {
1211         struct vop_searchfs_args a;
1212         a.a_desc = VDESC(vop_searchfs);
1213         a.a_vp = vp;
1214         a.a_searchparams1 = searchparams1;
1215         a.a_searchparams2 = searchparams2;
1216         a.a_searchattrs = searchattrs;
1217         a.a_maxmatches = maxmatches;
1218         a.a_timelimit = timelimit;
1219         a.a_returnattrs = returnattrs;
1220         a.a_nummatches = nummatches;
1221         a.a_scriptcode = scriptcode;
1222         a.a_options = options;
1223         a.a_uio = uio;
1224         a.a_searchstate = searchstate;
1225         return (VCALL(vp, VOFFSET(vop_searchfs), &a));
1226 }
1227
1228 struct vop_copyfile_args {
1229         struct vnodeop_desc *a_desc;
1230         struct vnode *a_fvp;
1231         struct vnode *a_tdvp;
1232         struct vnode *a_tvp;
1233         struct componentname *a_tcnp;
1234         int a_mode;
1235         int a_flags;
1236 };
1237 extern struct vnodeop_desc vop_copyfile_desc;
1238 #define VOP_COPYFILE(fvp, tdvp, tvp, tcnp, mode, flags) _VOP_COPYFILE(fvp, tdvp, tvp, tcnp, mode, flags)
1239 static __inline int _VOP_COPYFILE(struct vnode *fvp, struct vnode *tdvp, struct vnode *tvp, struct componentname *tcnp, int mode, int flags)
1240 {
1241         struct vop_copyfile_args a;
1242         a.a_desc = VDESC(vop_copyfile);
1243         a.a_fvp = fvp;
1244         a.a_tdvp = tdvp;
1245         a.a_tvp = tvp;
1246         a.a_tcnp = tcnp;
1247         a.a_mode = mode;
1248         a.a_flags = flags;
1249         return (VCALL(fvp, VOFFSET(vop_copyfile), &a));
1250 }
1251
1252 struct vop_blktooff_args {
1253         struct vnodeop_desc *a_desc;
1254         struct vnode *a_vp;
1255         daddr_t a_lblkno;
1256         off_t *a_offset;
1257 };
1258 extern struct vnodeop_desc vop_blktooff_desc;
1259 #define VOP_BLKTOOFF(vp, lblkno, offset) _VOP_BLKTOOFF(vp, lblkno, offset)
1260 static __inline int _VOP_BLKTOOFF(struct vnode *vp, daddr_t lblkno, off_t *offset)
1261 {
1262         struct vop_blktooff_args a;
1263         a.a_desc = VDESC(vop_blktooff);
1264         a.a_vp = vp;
1265         a.a_lblkno = lblkno;
1266         a.a_offset = offset;
1267         return (VCALL(vp, VOFFSET(vop_blktooff), &a));
1268 }
1269
1270 struct vop_offtoblk_args {
1271         struct vnodeop_desc *a_desc;
1272         struct vnode *a_vp;
1273         off_t a_offset;
1274         daddr_t *a_lblkno;
1275 };
1276 extern struct vnodeop_desc vop_offtoblk_desc;
1277 #define VOP_OFFTOBLK(vp, offset, lblkno) _VOP_OFFTOBLK(vp, offset, lblkno)
1278 static __inline int _VOP_OFFTOBLK(struct vnode *vp, off_t offset, daddr_t *lblkno)
1279 {
1280         struct vop_offtoblk_args a;
1281         a.a_desc = VDESC(vop_offtoblk);
1282         a.a_vp = vp;
1283         a.a_offset = offset;
1284         a.a_lblkno = lblkno;
1285         return (VCALL(vp, VOFFSET(vop_offtoblk), &a));
1286 }
1287
1288 struct vop_cmap_args {
1289         struct vnodeop_desc *a_desc;
1290         struct vnode *a_vp;
1291         off_t a_foffset;
1292         size_t a_size;
1293         daddr_t *a_bpn;
1294         size_t *a_run;
1295         void *a_poff;
1296 };
1297 extern struct vnodeop_desc vop_cmap_desc;
1298 #define VOP_CMAP(vp, foffset, size, bpn, run, poff) _VOP_CMAP(vp, foffset, size, bpn, run, poff)
1299 static __inline int _VOP_CMAP(struct vnode *vp, off_t foffset, size_t size, daddr_t *bpn, size_t *run, void *poff)
1300 {
1301         struct vop_cmap_args a;
1302         a.a_desc = VDESC(vop_cmap);
1303         a.a_vp = vp;
1304         a.a_foffset = foffset;
1305         a.a_size = size;
1306         a.a_bpn = bpn;
1307         a.a_run = run;
1308         a.a_poff = poff;
1309         return (VCALL(vp, VOFFSET(vop_cmap), &a));
1310 }
1311
1312 /* Special cases: */
1313 #include <sys/buf.h>
1314 #include <sys/vm.h>
1315
1316 struct vop_strategy_args {
1317         struct vnodeop_desc *a_desc;
1318         struct buf *a_bp;
1319 };
1320 extern struct vnodeop_desc vop_strategy_desc;
1321 #define VOP_STRATEGY(bp) _VOP_STRATEGY(bp)
1322 static __inline int _VOP_STRATEGY(struct buf *bp)
1323 {
1324         struct vop_strategy_args a;
1325         a.a_desc = VDESC(vop_strategy);
1326         a.a_bp = bp;
1327         return (VCALL(bp->b_vp, VOFFSET(vop_strategy), &a));
1328 }
1329
1330 struct vop_bwrite_args {
1331         struct vnodeop_desc *a_desc;
1332         struct buf *a_bp;
1333 };
1334 extern struct vnodeop_desc vop_bwrite_desc;
1335 #define VOP_BWRITE(bp) _VOP_BWRITE(bp)
1336 static __inline int _VOP_BWRITE(struct buf *bp)
1337 {
1338         struct vop_bwrite_args a;
1339         a.a_desc = VDESC(vop_bwrite);
1340         a.a_bp = bp;
1341         return (VCALL(bp->b_vp, VOFFSET(vop_bwrite), &a));
1342 }
1343
1344 /* End of special cases. */
1345
1346 #endif /* __APPLE_API_UNSTABLE */
1347 #endif /* !_SYS_VNODE_IF_H_ */