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