src/afs/FBSD/vnode_if_4x.h

   1 /*
   2  * This file is produced automatically.
   3  * Do not modify anything in here by hand.
   4  *
   5  * Created from @(#)vnode_if.sh 8.1 (Berkeley) 6/10/93
   6  */
   7
   8 extern struct vnodeop_desc vop_default_desc;
   9 struct vop_islocked_args {
  10     struct vnodeop_desc *a_desc;
  11     struct vnode *a_vp;
  12     struct proc *a_p;
  13 };
  14 extern struct vnodeop_desc vop_islocked_desc;
  15 static __inline int VOP_ISLOCKED __P((struct vnode * vp, struct proc * p));
  16 static __inline int
  17 VOP_ISLOCKED(vp, p)
  18      struct vnode *vp;
  19      struct proc *p;
  20 {
  21     struct vop_islocked_args a;
  22     int rc;
  23     a.a_desc = VDESC(vop_islocked);
  24     a.a_vp = vp;
  25     a.a_p = p;
  26     rc = VCALL(vp, VOFFSET(vop_islocked), &a);
  27     return (rc);
  28 }
  29 struct vop_lookup_args {
  30     struct vnodeop_desc *a_desc;
  31     struct vnode *a_dvp;
  32     struct vnode **a_vpp;
  33     struct componentname *a_cnp;
  34 };
  35 extern struct vnodeop_desc vop_lookup_desc;
  36 static __inline int VOP_LOOKUP
  37 __P((struct vnode * dvp, struct vnode ** vpp, struct componentname * cnp));
  38 static __inline int
  39 VOP_LOOKUP(dvp, vpp, cnp)
  40      struct vnode *dvp;
  41      struct vnode **vpp;
  42      struct componentname *cnp;
  43 {
  44     struct vop_lookup_args a;
  45     int rc;
  46     a.a_desc = VDESC(vop_lookup);
  47     a.a_dvp = dvp;
  48     a.a_vpp = vpp;
  49     a.a_cnp = cnp;
  50     rc = VCALL(dvp, VOFFSET(vop_lookup), &a);
  51     return (rc);
  52 }
  53 struct vop_cachedlookup_args {
  54     struct vnodeop_desc *a_desc;
  55     struct vnode *a_dvp;
  56     struct vnode **a_vpp;
  57     struct componentname *a_cnp;
  58 };
  59 extern struct vnodeop_desc vop_cachedlookup_desc;
  60 static __inline int VOP_CACHEDLOOKUP
  61 __P((struct vnode * dvp, struct vnode ** vpp, struct componentname * cnp));
  62 static __inline int
  63 VOP_CACHEDLOOKUP(dvp, vpp, cnp)
  64      struct vnode *dvp;
  65      struct vnode **vpp;
  66      struct componentname *cnp;
  67 {
  68     struct vop_cachedlookup_args a;
  69     int rc;
  70     a.a_desc = VDESC(vop_cachedlookup);
  71     a.a_dvp = dvp;
  72     a.a_vpp = vpp;
  73     a.a_cnp = cnp;
  74     rc = VCALL(dvp, VOFFSET(vop_cachedlookup), &a);
  75     return (rc);
  76 }
  77 struct vop_create_args {
  78     struct vnodeop_desc *a_desc;
  79     struct vnode *a_dvp;
  80     struct vnode **a_vpp;
  81     struct componentname *a_cnp;
  82     struct vattr *a_vap;
  83 };
  84 extern struct vnodeop_desc vop_create_desc;
  85 static __inline int VOP_CREATE
  86 __P((struct vnode * dvp, struct vnode ** vpp, struct componentname * cnp,
  87      struct vattr * vap));
  88 static __inline int
  89 VOP_CREATE(dvp, vpp, cnp, vap)
  90      struct vnode *dvp;
  91      struct vnode **vpp;
  92      struct componentname *cnp;
  93      struct vattr *vap;
  94 {
  95     struct vop_create_args a;
  96     int rc;
  97     a.a_desc = VDESC(vop_create);
  98     a.a_dvp = dvp;
  99     a.a_vpp = vpp;
 100     a.a_cnp = cnp;
 101     a.a_vap = vap;
 102     rc = VCALL(dvp, VOFFSET(vop_create), &a);
 103     return (rc);
 104 }
 105 struct vop_whiteout_args {
 106     struct vnodeop_desc *a_desc;
 107     struct vnode *a_dvp;
 108     struct componentname *a_cnp;
 109     int a_flags;
 110 };
 111 extern struct vnodeop_desc vop_whiteout_desc;
 112 static __inline int VOP_WHITEOUT
 113 __P((struct vnode * dvp, struct componentname * cnp, int flags));
 114 static __inline int
 115 VOP_WHITEOUT(dvp, cnp, flags)
 116      struct vnode *dvp;
 117      struct componentname *cnp;
 118      int flags;
 119 {
 120     struct vop_whiteout_args a;
 121     int rc;
 122     a.a_desc = VDESC(vop_whiteout);
 123     a.a_dvp = dvp;
 124     a.a_cnp = cnp;
 125     a.a_flags = flags;
 126     rc = VCALL(dvp, VOFFSET(vop_whiteout), &a);
 127     return (rc);
 128 }
 129 struct vop_mknod_args {
 130     struct vnodeop_desc *a_desc;
 131     struct vnode *a_dvp;
 132     struct vnode **a_vpp;
 133     struct componentname *a_cnp;
 134     struct vattr *a_vap;
 135 };
 136 extern struct vnodeop_desc vop_mknod_desc;
 137 static __inline int VOP_MKNOD
 138 __P((struct vnode * dvp, struct vnode ** vpp, struct componentname * cnp,
 139      struct vattr * vap));
 140 static __inline int
 141 VOP_MKNOD(dvp, vpp, cnp, vap)
 142      struct vnode *dvp;
 143      struct vnode **vpp;
 144      struct componentname *cnp;
 145      struct vattr *vap;
 146 {
 147     struct vop_mknod_args a;
 148     int rc;
 149     a.a_desc = VDESC(vop_mknod);
 150     a.a_dvp = dvp;
 151     a.a_vpp = vpp;
 152     a.a_cnp = cnp;
 153     a.a_vap = vap;
 154     rc = VCALL(dvp, VOFFSET(vop_mknod), &a);
 155     return (rc);
 156 }
 157 struct vop_open_args {
 158     struct vnodeop_desc *a_desc;
 159     struct vnode *a_vp;
 160     int a_mode;
 161     struct ucred *a_cred;
 162     struct proc *a_p;
 163 };
 164 extern struct vnodeop_desc vop_open_desc;
 165 static __inline int VOP_OPEN
 166 __P((struct vnode * vp, int mode, struct ucred * cred, struct proc * p));
 167 static __inline int
 168 VOP_OPEN(vp, mode, cred, p)
 169      struct vnode *vp;
 170      int mode;
 171      struct ucred *cred;
 172      struct proc *p;
 173 {
 174     struct vop_open_args a;
 175     int rc;
 176     a.a_desc = VDESC(vop_open);
 177     a.a_vp = vp;
 178     a.a_mode = mode;
 179     a.a_cred = cred;
 180     a.a_p = p;
 181     rc = VCALL(vp, VOFFSET(vop_open), &a);
 182     return (rc);
 183 }
 184 struct vop_close_args {
 185     struct vnodeop_desc *a_desc;
 186     struct vnode *a_vp;
 187     int a_fflag;
 188     struct ucred *a_cred;
 189     struct proc *a_p;
 190 };
 191 extern struct vnodeop_desc vop_close_desc;
 192 static __inline int VOP_CLOSE
 193 __P((struct vnode * vp, int fflag, struct ucred * cred, struct proc * p));
 194 static __inline int
 195 VOP_CLOSE(vp, fflag, cred, p)
 196      struct vnode *vp;
 197      int fflag;
 198      struct ucred *cred;
 199      struct proc *p;
 200 {
 201     struct vop_close_args a;
 202     int rc;
 203     a.a_desc = VDESC(vop_close);
 204     a.a_vp = vp;
 205     a.a_fflag = fflag;
 206     a.a_cred = cred;
 207     a.a_p = p;
 208     rc = VCALL(vp, VOFFSET(vop_close), &a);
 209     return (rc);
 210 }
 211 struct vop_access_args {
 212     struct vnodeop_desc *a_desc;
 213     struct vnode *a_vp;
 214     int a_mode;
 215     struct ucred *a_cred;
 216     struct proc *a_p;
 217 };
 218 extern struct vnodeop_desc vop_access_desc;
 219 static __inline int VOP_ACCESS
 220 __P((struct vnode * vp, int mode, struct ucred * cred, struct proc * p));
 221 static __inline int
 222 VOP_ACCESS(vp, mode, cred, p)
 223      struct vnode *vp;
 224      int mode;
 225      struct ucred *cred;
 226      struct proc *p;
 227 {
 228     struct vop_access_args a;
 229     int rc;
 230     a.a_desc = VDESC(vop_access);
 231     a.a_vp = vp;
 232     a.a_mode = mode;
 233     a.a_cred = cred;
 234     a.a_p = p;
 235     rc = VCALL(vp, VOFFSET(vop_access), &a);
 236     return (rc);
 237 }
 238 struct vop_getattr_args {
 239     struct vnodeop_desc *a_desc;
 240     struct vnode *a_vp;
 241     struct vattr *a_vap;
 242     struct ucred *a_cred;
 243     struct proc *a_p;
 244 };
 245 extern struct vnodeop_desc vop_getattr_desc;
 246 static __inline int VOP_GETATTR
 247 __P((struct vnode * vp, struct vattr * vap, struct ucred * cred,
 248      struct proc * p));
 249 static __inline int
 250 VOP_GETATTR(vp, vap, cred, p)
 251      struct vnode *vp;
 252      struct vattr *vap;
 253      struct ucred *cred;
 254      struct proc *p;
 255 {
 256     struct vop_getattr_args a;
 257     int rc;
 258     a.a_desc = VDESC(vop_getattr);
 259     a.a_vp = vp;
 260     a.a_vap = vap;
 261     a.a_cred = cred;
 262     a.a_p = p;
 263     rc = VCALL(vp, VOFFSET(vop_getattr), &a);
 264     return (rc);
 265 }
 266 struct vop_setattr_args {
 267     struct vnodeop_desc *a_desc;
 268     struct vnode *a_vp;
 269     struct vattr *a_vap;
 270     struct ucred *a_cred;
 271     struct proc *a_p;
 272 };
 273 extern struct vnodeop_desc vop_setattr_desc;
 274 static __inline int VOP_SETATTR
 275 __P((struct vnode * vp, struct vattr * vap, struct ucred * cred,
 276      struct proc * p));
 277 static __inline int
 278 VOP_SETATTR(vp, vap, cred, p)
 279      struct vnode *vp;
 280      struct vattr *vap;
 281      struct ucred *cred;
 282      struct proc *p;
 283 {
 284     struct vop_setattr_args a;
 285     int rc;
 286     a.a_desc = VDESC(vop_setattr);
 287     a.a_vp = vp;
 288     a.a_vap = vap;
 289     a.a_cred = cred;
 290     a.a_p = p;
 291     rc = VCALL(vp, VOFFSET(vop_setattr), &a);
 292     return (rc);
 293 }
 294 struct vop_read_args {
 295     struct vnodeop_desc *a_desc;
 296     struct vnode *a_vp;
 297     struct uio *a_uio;
 298     int a_ioflag;
 299     struct ucred *a_cred;
 300 };
 301 extern struct vnodeop_desc vop_read_desc;
 302 static __inline int VOP_READ
 303 __P((struct vnode * vp, struct uio * uio, int ioflag, struct ucred * cred));
 304 static __inline int
 305 VOP_READ(vp, uio, ioflag, cred)
 306      struct vnode *vp;
 307      struct uio *uio;
 308      int ioflag;
 309      struct ucred *cred;
 310 {
 311     struct vop_read_args a;
 312     int rc;
 313     a.a_desc = VDESC(vop_read);
 314     a.a_vp = vp;
 315     a.a_uio = uio;
 316     a.a_ioflag = ioflag;
 317     a.a_cred = cred;
 318     rc = VCALL(vp, VOFFSET(vop_read), &a);
 319     return (rc);
 320 }
 321 struct vop_write_args {
 322     struct vnodeop_desc *a_desc;
 323     struct vnode *a_vp;
 324     struct uio *a_uio;
 325     int a_ioflag;
 326     struct ucred *a_cred;
 327 };
 328 extern struct vnodeop_desc vop_write_desc;
 329 static __inline int VOP_WRITE
 330 __P((struct vnode * vp, struct uio * uio, int ioflag, struct ucred * cred));
 331 static __inline int
 332 VOP_WRITE(vp, uio, ioflag, cred)
 333      struct vnode *vp;
 334      struct uio *uio;
 335      int ioflag;
 336      struct ucred *cred;
 337 {
 338     struct vop_write_args a;
 339     int rc;
 340     a.a_desc = VDESC(vop_write);
 341     a.a_vp = vp;
 342     a.a_uio = uio;
 343     a.a_ioflag = ioflag;
 344     a.a_cred = cred;
 345     rc = VCALL(vp, VOFFSET(vop_write), &a);
 346     return (rc);
 347 }
 348 struct vop_lease_args {
 349     struct vnodeop_desc *a_desc;
 350     struct vnode *a_vp;
 351     struct proc *a_p;
 352     struct ucred *a_cred;
 353     int a_flag;
 354 };
 355 extern struct vnodeop_desc vop_lease_desc;
 356 static __inline int VOP_LEASE
 357 __P((struct vnode * vp, struct proc * p, struct ucred * cred, int flag));
 358 static __inline int
 359 VOP_LEASE(vp, p, cred, flag)
 360      struct vnode *vp;
 361      struct proc *p;
 362      struct ucred *cred;
 363      int flag;
 364 {
 365     struct vop_lease_args a;
 366     int rc;
 367     a.a_desc = VDESC(vop_lease);
 368     a.a_vp = vp;
 369     a.a_p = p;
 370     a.a_cred = cred;
 371     a.a_flag = flag;
 372     rc = VCALL(vp, VOFFSET(vop_lease), &a);
 373     return (rc);
 374 }
 375 struct vop_ioctl_args {
 376     struct vnodeop_desc *a_desc;
 377     struct vnode *a_vp;
 378     u_long a_command;
 379     caddr_t a_data;
 380     int a_fflag;
 381     struct ucred *a_cred;
 382     struct proc *a_p;
 383 };
 384 extern struct vnodeop_desc vop_ioctl_desc;
 385 static __inline int VOP_IOCTL
 386 __P((struct vnode * vp, u_long command, caddr_t data, int fflag,
 387      struct ucred * cred, struct proc * p));
 388 static __inline int
 389 VOP_IOCTL(vp, command, data, fflag, cred, p)
 390      struct vnode *vp;
 391      u_long command;
 392      caddr_t data;
 393      int fflag;
 394      struct ucred *cred;
 395      struct proc *p;
 396 {
 397     struct vop_ioctl_args a;
 398     int rc;
 399     a.a_desc = VDESC(vop_ioctl);
 400     a.a_vp = vp;
 401     a.a_command = command;
 402     a.a_data = data;
 403     a.a_fflag = fflag;
 404     a.a_cred = cred;
 405     a.a_p = p;
 406     rc = VCALL(vp, VOFFSET(vop_ioctl), &a);
 407     return (rc);
 408 }
 409 struct vop_poll_args {
 410     struct vnodeop_desc *a_desc;
 411     struct vnode *a_vp;
 412     int a_events;
 413     struct ucred *a_cred;
 414     struct proc *a_p;
 415 };
 416 extern struct vnodeop_desc vop_poll_desc;
 417 static __inline int VOP_POLL
 418 __P((struct vnode * vp, int events, struct ucred * cred, struct proc * p));
 419 static __inline int
 420 VOP_POLL(vp, events, cred, p)
 421      struct vnode *vp;
 422      int events;
 423      struct ucred *cred;
 424      struct proc *p;
 425 {
 426     struct vop_poll_args a;
 427     int rc;
 428     a.a_desc = VDESC(vop_poll);
 429     a.a_vp = vp;
 430     a.a_events = events;
 431     a.a_cred = cred;
 432     a.a_p = p;
 433     rc = VCALL(vp, VOFFSET(vop_poll), &a);
 434     return (rc);
 435 }
 436 struct vop_kqfilter_args {
 437     struct vnodeop_desc *a_desc;
 438     struct vnode *a_vp;
 439     struct knote *a_kn;
 440 };
 441 extern struct vnodeop_desc vop_kqfilter_desc;
 442 static __inline int VOP_KQFILTER __P((struct vnode * vp, struct knote * kn));
 443 static __inline int
 444 VOP_KQFILTER(vp, kn)
 445      struct vnode *vp;
 446      struct knote *kn;
 447 {
 448     struct vop_kqfilter_args a;
 449     int rc;
 450     a.a_desc = VDESC(vop_kqfilter);
 451     a.a_vp = vp;
 452     a.a_kn = kn;
 453     rc = VCALL(vp, VOFFSET(vop_kqfilter), &a);
 454     return (rc);
 455 }
 456 struct vop_revoke_args {
 457     struct vnodeop_desc *a_desc;
 458     struct vnode *a_vp;
 459     int a_flags;
 460 };
 461 extern struct vnodeop_desc vop_revoke_desc;
 462 static __inline int VOP_REVOKE __P((struct vnode * vp, int flags));
 463 static __inline int
 464 VOP_REVOKE(vp, flags)
 465      struct vnode *vp;
 466      int flags;
 467 {
 468     struct vop_revoke_args a;
 469     int rc;
 470     a.a_desc = VDESC(vop_revoke);
 471     a.a_vp = vp;
 472     a.a_flags = flags;
 473     rc = VCALL(vp, VOFFSET(vop_revoke), &a);
 474     return (rc);
 475 }
 476 struct vop_mmap_args {
 477     struct vnodeop_desc *a_desc;
 478     struct vnode *a_vp;
 479     int a_fflags;
 480     struct ucred *a_cred;
 481     struct proc *a_p;
 482 };
 483 extern struct vnodeop_desc vop_mmap_desc;
 484 static __inline int VOP_MMAP
 485 __P((struct vnode * vp, int fflags, struct ucred * cred, struct proc * p));
 486 static __inline int
 487 VOP_MMAP(vp, fflags, cred, p)
 488      struct vnode *vp;
 489      int fflags;
 490      struct ucred *cred;
 491      struct proc *p;
 492 {
 493     struct vop_mmap_args a;
 494     int rc;
 495     a.a_desc = VDESC(vop_mmap);
 496     a.a_vp = vp;
 497     a.a_fflags = fflags;
 498     a.a_cred = cred;
 499     a.a_p = p;
 500     rc = VCALL(vp, VOFFSET(vop_mmap), &a);
 501     return (rc);
 502 }
 503 struct vop_fsync_args {
 504     struct vnodeop_desc *a_desc;
 505     struct vnode *a_vp;
 506     struct ucred *a_cred;
 507     int a_waitfor;
 508     struct proc *a_p;
 509 };
 510 extern struct vnodeop_desc vop_fsync_desc;
 511 static __inline int VOP_FSYNC
 512 __P((struct vnode * vp, struct ucred * cred, int waitfor, struct proc * p));
 513 static __inline int
 514 VOP_FSYNC(vp, cred, waitfor, p)
 515      struct vnode *vp;
 516      struct ucred *cred;
 517      int waitfor;
 518      struct proc *p;
 519 {
 520     struct vop_fsync_args a;
 521     int rc;
 522     a.a_desc = VDESC(vop_fsync);
 523     a.a_vp = vp;
 524     a.a_cred = cred;
 525     a.a_waitfor = waitfor;
 526     a.a_p = p;
 527     rc = VCALL(vp, VOFFSET(vop_fsync), &a);
 528     return (rc);
 529 }
 530 struct vop_remove_args {
 531     struct vnodeop_desc *a_desc;
 532     struct vnode *a_dvp;
 533     struct vnode *a_vp;
 534     struct componentname *a_cnp;
 535 };
 536 extern struct vnodeop_desc vop_remove_desc;
 537 static __inline int VOP_REMOVE
 538 __P((struct vnode * dvp, struct vnode * vp, struct componentname * cnp));
 539 static __inline int
 540 VOP_REMOVE(dvp, vp, cnp)
 541      struct vnode *dvp;
 542      struct vnode *vp;
 543      struct componentname *cnp;
 544 {
 545     struct vop_remove_args a;
 546     int rc;
 547     a.a_desc = VDESC(vop_remove);
 548     a.a_dvp = dvp;
 549     a.a_vp = vp;
 550     a.a_cnp = cnp;
 551     rc = VCALL(dvp, VOFFSET(vop_remove), &a);
 552     return (rc);
 553 }
 554 struct vop_link_args {
 555     struct vnodeop_desc *a_desc;
 556     struct vnode *a_tdvp;
 557     struct vnode *a_vp;
 558     struct componentname *a_cnp;
 559 };
 560 extern struct vnodeop_desc vop_link_desc;
 561 static __inline int VOP_LINK
 562 __P((struct vnode * tdvp, struct vnode * vp, struct componentname * cnp));
 563 static __inline int
 564 VOP_LINK(tdvp, vp, cnp)
 565      struct vnode *tdvp;
 566      struct vnode *vp;
 567      struct componentname *cnp;
 568 {
 569     struct vop_link_args a;
 570     int rc;
 571     a.a_desc = VDESC(vop_link);
 572     a.a_tdvp = tdvp;
 573     a.a_vp = vp;
 574     a.a_cnp = cnp;
 575     rc = VCALL(tdvp, VOFFSET(vop_link), &a);
 576     return (rc);
 577 }
 578 struct vop_rename_args {
 579     struct vnodeop_desc *a_desc;
 580     struct vnode *a_fdvp;
 581     struct vnode *a_fvp;
 582     struct componentname *a_fcnp;
 583     struct vnode *a_tdvp;
 584     struct vnode *a_tvp;
 585     struct componentname *a_tcnp;
 586 };
 587 extern struct vnodeop_desc vop_rename_desc;
 588 static __inline int VOP_RENAME
 589 __P((struct vnode * fdvp, struct vnode * fvp, struct componentname * fcnp,
 590      struct vnode * tdvp, struct vnode * tvp, struct componentname * tcnp));
 591 static __inline int
 592 VOP_RENAME(fdvp, fvp, fcnp, tdvp, tvp, tcnp)
 593      struct vnode *fdvp;
 594      struct vnode *fvp;
 595      struct componentname *fcnp;
 596      struct vnode *tdvp;
 597      struct vnode *tvp;
 598      struct componentname *tcnp;
 599 {
 600     struct vop_rename_args a;
 601     int rc;
 602     a.a_desc = VDESC(vop_rename);
 603     a.a_fdvp = fdvp;
 604     a.a_fvp = fvp;
 605     a.a_fcnp = fcnp;
 606     a.a_tdvp = tdvp;
 607     a.a_tvp = tvp;
 608     a.a_tcnp = tcnp;
 609     rc = VCALL(fdvp, VOFFSET(vop_rename), &a);
 610     return (rc);
 611 }
 612 struct vop_mkdir_args {
 613     struct vnodeop_desc *a_desc;
 614     struct vnode *a_dvp;
 615     struct vnode **a_vpp;
 616     struct componentname *a_cnp;
 617     struct vattr *a_vap;
 618 };
 619 extern struct vnodeop_desc vop_mkdir_desc;
 620 static __inline int VOP_MKDIR
 621 __P((struct vnode * dvp, struct vnode ** vpp, struct componentname * cnp,
 622      struct vattr * vap));
 623 static __inline int
 624 VOP_MKDIR(dvp, vpp, cnp, vap)
 625      struct vnode *dvp;
 626      struct vnode **vpp;
 627      struct componentname *cnp;
 628      struct vattr *vap;
 629 {
 630     struct vop_mkdir_args a;
 631     int rc;
 632     a.a_desc = VDESC(vop_mkdir);
 633     a.a_dvp = dvp;
 634     a.a_vpp = vpp;
 635     a.a_cnp = cnp;
 636     a.a_vap = vap;
 637     rc = VCALL(dvp, VOFFSET(vop_mkdir), &a);
 638     return (rc);
 639 }
 640 struct vop_rmdir_args {
 641     struct vnodeop_desc *a_desc;
 642     struct vnode *a_dvp;
 643     struct vnode *a_vp;
 644     struct componentname *a_cnp;
 645 };
 646 extern struct vnodeop_desc vop_rmdir_desc;
 647 static __inline int VOP_RMDIR
 648 __P((struct vnode * dvp, struct vnode * vp, struct componentname * cnp));
 649 static __inline int
 650 VOP_RMDIR(dvp, vp, cnp)
 651      struct vnode *dvp;
 652      struct vnode *vp;
 653      struct componentname *cnp;
 654 {
 655     struct vop_rmdir_args a;
 656     int rc;
 657     a.a_desc = VDESC(vop_rmdir);
 658     a.a_dvp = dvp;
 659     a.a_vp = vp;
 660     a.a_cnp = cnp;
 661     rc = VCALL(dvp, VOFFSET(vop_rmdir), &a);
 662     return (rc);
 663 }
 664 struct vop_symlink_args {
 665     struct vnodeop_desc *a_desc;
 666     struct vnode *a_dvp;
 667     struct vnode **a_vpp;
 668     struct componentname *a_cnp;
 669     struct vattr *a_vap;
 670     char *a_target;
 671 };
 672 extern struct vnodeop_desc vop_symlink_desc;
 673 static __inline int VOP_SYMLINK
 674 __P((struct vnode * dvp, struct vnode ** vpp, struct componentname * cnp,
 675      struct vattr * vap, char *target));
 676 static __inline int
 677 VOP_SYMLINK(dvp, vpp, cnp, vap, target)
 678      struct vnode *dvp;
 679      struct vnode **vpp;
 680      struct componentname *cnp;
 681      struct vattr *vap;
 682      char *target;
 683 {
 684     struct vop_symlink_args a;
 685     int rc;
 686     a.a_desc = VDESC(vop_symlink);
 687     a.a_dvp = dvp;
 688     a.a_vpp = vpp;
 689     a.a_cnp = cnp;
 690     a.a_vap = vap;
 691     a.a_target = target;
 692     rc = VCALL(dvp, VOFFSET(vop_symlink), &a);
 693     return (rc);
 694 }
 695 struct vop_readdir_args {
 696     struct vnodeop_desc *a_desc;
 697     struct vnode *a_vp;
 698     struct uio *a_uio;
 699     struct ucred *a_cred;
 700     int *a_eofflag;
 701     int *a_ncookies;
 702     u_long **a_cookies;
 703 };
 704 extern struct vnodeop_desc vop_readdir_desc;
 705 static __inline int VOP_READDIR
 706 __P((struct vnode * vp, struct uio * uio, struct ucred * cred, int *eofflag,
 707      int *ncookies, u_long ** cookies));
 708 static __inline int
 709 VOP_READDIR(vp, uio, cred, eofflag, ncookies, cookies)
 710      struct vnode *vp;
 711      struct uio *uio;
 712      struct ucred *cred;
 713      int *eofflag;
 714      int *ncookies;
 715      u_long **cookies;
 716 {
 717     struct vop_readdir_args a;
 718     int rc;
 719     a.a_desc = VDESC(vop_readdir);
 720     a.a_vp = vp;
 721     a.a_uio = uio;
 722     a.a_cred = cred;
 723     a.a_eofflag = eofflag;
 724     a.a_ncookies = ncookies;
 725     a.a_cookies = cookies;
 726     rc = VCALL(vp, VOFFSET(vop_readdir), &a);
 727     return (rc);
 728 }
 729 struct vop_readlink_args {
 730     struct vnodeop_desc *a_desc;
 731     struct vnode *a_vp;
 732     struct uio *a_uio;
 733     struct ucred *a_cred;
 734 };
 735 extern struct vnodeop_desc vop_readlink_desc;
 736 static __inline int VOP_READLINK
 737 __P((struct vnode * vp, struct uio * uio, struct ucred * cred));
 738 static __inline int
 739 VOP_READLINK(vp, uio, cred)
 740      struct vnode *vp;
 741      struct uio *uio;
 742      struct ucred *cred;
 743 {
 744     struct vop_readlink_args a;
 745     int rc;
 746     a.a_desc = VDESC(vop_readlink);
 747     a.a_vp = vp;
 748     a.a_uio = uio;
 749     a.a_cred = cred;
 750     rc = VCALL(vp, VOFFSET(vop_readlink), &a);
 751     return (rc);
 752 }
 753 struct vop_inactive_args {
 754     struct vnodeop_desc *a_desc;
 755     struct vnode *a_vp;
 756     struct proc *a_p;
 757 };
 758 extern struct vnodeop_desc vop_inactive_desc;
 759 static __inline int VOP_INACTIVE __P((struct vnode * vp, struct proc * p));
 760 static __inline int
 761 VOP_INACTIVE(vp, p)
 762      struct vnode *vp;
 763      struct proc *p;
 764 {
 765     struct vop_inactive_args a;
 766     int rc;
 767     a.a_desc = VDESC(vop_inactive);
 768     a.a_vp = vp;
 769     a.a_p = p;
 770     rc = VCALL(vp, VOFFSET(vop_inactive), &a);
 771     return (rc);
 772 }
 773 struct vop_reclaim_args {
 774     struct vnodeop_desc *a_desc;
 775     struct vnode *a_vp;
 776     struct proc *a_p;
 777 };
 778 extern struct vnodeop_desc vop_reclaim_desc;
 779 static __inline int VOP_RECLAIM __P((struct vnode * vp, struct proc * p));
 780 static __inline int
 781 VOP_RECLAIM(vp, p)
 782      struct vnode *vp;
 783      struct proc *p;
 784 {
 785     struct vop_reclaim_args a;
 786     int rc;
 787     a.a_desc = VDESC(vop_reclaim);
 788     a.a_vp = vp;
 789     a.a_p = p;
 790     rc = VCALL(vp, VOFFSET(vop_reclaim), &a);
 791     return (rc);
 792 }
 793 struct vop_lock_args {
 794     struct vnodeop_desc *a_desc;
 795     struct vnode *a_vp;
 796     int a_flags;
 797     struct proc *a_p;
 798 };
 799 extern struct vnodeop_desc vop_lock_desc;
 800 static __inline int VOP_LOCK
 801 __P((struct vnode * vp, int flags, struct proc * p));
 802 static __inline int
 803 VOP_LOCK(vp, flags, p)
 804      struct vnode *vp;
 805      int flags;
 806      struct proc *p;
 807 {
 808     struct vop_lock_args a;
 809     int rc;
 810     a.a_desc = VDESC(vop_lock);
 811     a.a_vp = vp;
 812     a.a_flags = flags;
 813     a.a_p = p;
 814     rc = VCALL(vp, VOFFSET(vop_lock), &a);
 815     return (rc);
 816 }
 817 struct vop_unlock_args {
 818     struct vnodeop_desc *a_desc;
 819     struct vnode *a_vp;
 820     int a_flags;
 821     struct proc *a_p;
 822 };
 823 extern struct vnodeop_desc vop_unlock_desc;
 824 static __inline int VOP_UNLOCK
 825 __P((struct vnode * vp, int flags, struct proc * p));
 826 static __inline int
 827 VOP_UNLOCK(vp, flags, p)
 828      struct vnode *vp;
 829      int flags;
 830      struct proc *p;
 831 {
 832     struct vop_unlock_args a;
 833     int rc;
 834     a.a_desc = VDESC(vop_unlock);
 835     a.a_vp = vp;
 836     a.a_flags = flags;
 837     a.a_p = p;
 838     rc = VCALL(vp, VOFFSET(vop_unlock), &a);
 839     return (rc);
 840 }
 841 struct vop_bmap_args {
 842     struct vnodeop_desc *a_desc;
 843     struct vnode *a_vp;
 844     daddr_t a_bn;
 845     struct vnode **a_vpp;
 846     daddr_t *a_bnp;
 847     int *a_runp;
 848     int *a_runb;
 849 };
 850 extern struct vnodeop_desc vop_bmap_desc;
 851 static __inline int VOP_BMAP
 852 __P((struct vnode * vp, daddr_t bn, struct vnode ** vpp, daddr_t * bnp,
 853      int *runp, int *runb));
 854 static __inline int
 855 VOP_BMAP(vp, bn, vpp, bnp, runp, runb)
 856      struct vnode *vp;
 857      daddr_t bn;
 858      struct vnode **vpp;
 859      daddr_t *bnp;
 860      int *runp;
 861      int *runb;
 862 {
 863     struct vop_bmap_args a;
 864     int rc;
 865     a.a_desc = VDESC(vop_bmap);
 866     a.a_vp = vp;
 867     a.a_bn = bn;
 868     a.a_vpp = vpp;
 869     a.a_bnp = bnp;
 870     a.a_runp = runp;
 871     a.a_runb = runb;
 872     rc = VCALL(vp, VOFFSET(vop_bmap), &a);
 873     return (rc);
 874 }
 875 struct vop_strategy_args {
 876     struct vnodeop_desc *a_desc;
 877     struct vnode *a_vp;
 878     struct buf *a_bp;
 879 };
 880 extern struct vnodeop_desc vop_strategy_desc;
 881 static __inline int VOP_STRATEGY __P((struct vnode * vp, struct buf * bp));
 882 static __inline int
 883 VOP_STRATEGY(vp, bp)
 884      struct vnode *vp;
 885      struct buf *bp;
 886 {
 887     struct vop_strategy_args a;
 888     int rc;
 889     a.a_desc = VDESC(vop_strategy);
 890     a.a_vp = vp;
 891     a.a_bp = bp;
 892     rc = VCALL(vp, VOFFSET(vop_strategy), &a);
 893     return (rc);
 894 }
 895 struct vop_print_args {
 896     struct vnodeop_desc *a_desc;
 897     struct vnode *a_vp;
 898 };
 899 extern struct vnodeop_desc vop_print_desc;
 900 static __inline int VOP_PRINT __P((struct vnode * vp));
 901 static __inline int
 902 VOP_PRINT(vp)
 903      struct vnode *vp;
 904 {
 905     struct vop_print_args a;
 906     int rc;
 907     a.a_desc = VDESC(vop_print);
 908     a.a_vp = vp;
 909     rc = VCALL(vp, VOFFSET(vop_print), &a);
 910     return (rc);
 911 }
 912 struct vop_pathconf_args {
 913     struct vnodeop_desc *a_desc;
 914     struct vnode *a_vp;
 915     int a_name;
 916     register_t *a_retval;
 917 };
 918 extern struct vnodeop_desc vop_pathconf_desc;
 919 static __inline int VOP_PATHCONF
 920 __P((struct vnode * vp, int name, register_t * retval));
 921 static __inline int
 922 VOP_PATHCONF(vp, name, retval)
 923      struct vnode *vp;
 924      int name;
 925      register_t *retval;
 926 {
 927     struct vop_pathconf_args a;
 928     int rc;
 929     a.a_desc = VDESC(vop_pathconf);
 930     a.a_vp = vp;
 931     a.a_name = name;
 932     a.a_retval = retval;
 933     rc = VCALL(vp, VOFFSET(vop_pathconf), &a);
 934     return (rc);
 935 }
 936 struct vop_advlock_args {
 937     struct vnodeop_desc *a_desc;
 938     struct vnode *a_vp;
 939     caddr_t a_id;
 940     int a_op;
 941     struct flock *a_fl;
 942     int a_flags;
 943 };
 944 extern struct vnodeop_desc vop_advlock_desc;
 945 static __inline int VOP_ADVLOCK
 946 __P((struct vnode * vp, caddr_t id, int op, struct flock * fl, int flags));
 947 static __inline int
 948 VOP_ADVLOCK(vp, id, op, fl, flags)
 949      struct vnode *vp;
 950      caddr_t id;
 951      int op;
 952      struct flock *fl;
 953      int flags;
 954 {
 955     struct vop_advlock_args a;
 956     int rc;
 957     a.a_desc = VDESC(vop_advlock);
 958     a.a_vp = vp;
 959     a.a_id = id;
 960     a.a_op = op;
 961     a.a_fl = fl;
 962     a.a_flags = flags;
 963     rc = VCALL(vp, VOFFSET(vop_advlock), &a);
 964     return (rc);
 965 }
 966 struct vop_balloc_args {
 967     struct vnodeop_desc *a_desc;
 968     struct vnode *a_vp;
 969     off_t a_startoffset;
 970     int a_size;
 971     struct ucred *a_cred;
 972     int a_flags;
 973     struct buf **a_bpp;
 974 };
 975 extern struct vnodeop_desc vop_balloc_desc;
 976 static __inline int VOP_BALLOC
 977 __P((struct vnode * vp, off_t startoffset, int size, struct ucred * cred,
 978      int flags, struct buf ** bpp));
 979 static __inline int
 980 VOP_BALLOC(vp, startoffset, size, cred, flags, bpp)
 981      struct vnode *vp;
 982      off_t startoffset;
 983      int size;
 984      struct ucred *cred;
 985      int flags;
 986      struct buf **bpp;
 987 {
 988     struct vop_balloc_args a;
 989     int rc;
 990     a.a_desc = VDESC(vop_balloc);
 991     a.a_vp = vp;
 992     a.a_startoffset = startoffset;
 993     a.a_size = size;
 994     a.a_cred = cred;
 995     a.a_flags = flags;
 996     a.a_bpp = bpp;
 997     rc = VCALL(vp, VOFFSET(vop_balloc), &a);
 998     return (rc);
 999 }
1000 struct vop_reallocblks_args {
1001     struct vnodeop_desc *a_desc;
1002     struct vnode *a_vp;
1003     struct cluster_save *a_buflist;
1004 };
1005 extern struct vnodeop_desc vop_reallocblks_desc;
1006 static __inline int VOP_REALLOCBLKS
1007 __P((struct vnode * vp, struct cluster_save * buflist));
1008 static __inline int
1009 VOP_REALLOCBLKS(vp, buflist)
1010      struct vnode *vp;
1011      struct cluster_save *buflist;
1012 {
1013     struct vop_reallocblks_args a;
1014     int rc;
1015     a.a_desc = VDESC(vop_reallocblks);
1016     a.a_vp = vp;
1017     a.a_buflist = buflist;
1018     rc = VCALL(vp, VOFFSET(vop_reallocblks), &a);
1019     return (rc);
1020 }
1021 struct vop_getpages_args {
1022     struct vnodeop_desc *a_desc;
1023     struct vnode *a_vp;
1024     vm_page_t *a_m;
1025     int a_count;
1026     int a_reqpage;
1027     vm_ooffset_t a_offset;
1028 };
1029 extern struct vnodeop_desc vop_getpages_desc;
1030 static __inline int VOP_GETPAGES
1031 __P((struct vnode * vp, vm_page_t * m, int count, int reqpage,
1032      vm_ooffset_t offset));
1033 static __inline int
1034 VOP_GETPAGES(vp, m, count, reqpage, offset)
1035      struct vnode *vp;
1036      vm_page_t *m;
1037      int count;
1038      int reqpage;
1039      vm_ooffset_t offset;
1040 {
1041     struct vop_getpages_args a;
1042     int rc;
1043     a.a_desc = VDESC(vop_getpages);
1044     a.a_vp = vp;
1045     a.a_m = m;
1046     a.a_count = count;
1047     a.a_reqpage = reqpage;
1048     a.a_offset = offset;
1049     rc = VCALL(vp, VOFFSET(vop_getpages), &a);
1050     return (rc);
1051 }
1052 struct vop_putpages_args {
1053     struct vnodeop_desc *a_desc;
1054     struct vnode *a_vp;
1055     vm_page_t *a_m;
1056     int a_count;
1057     int a_sync;
1058     int *a_rtvals;
1059     vm_ooffset_t a_offset;
1060 };
1061 extern struct vnodeop_desc vop_putpages_desc;
1062 static __inline int VOP_PUTPAGES
1063 __P((struct vnode * vp, vm_page_t * m, int count, int sync, int *rtvals,
1064      vm_ooffset_t offset));
1065 static __inline int
1066 VOP_PUTPAGES(vp, m, count, sync, rtvals, offset)
1067      struct vnode *vp;
1068      vm_page_t *m;
1069      int count;
1070      int sync;
1071      int *rtvals;
1072      vm_ooffset_t offset;
1073 {
1074     struct vop_putpages_args a;
1075     int rc;
1076     a.a_desc = VDESC(vop_putpages);
1077     a.a_vp = vp;
1078     a.a_m = m;
1079     a.a_count = count;
1080     a.a_sync = sync;
1081     a.a_rtvals = rtvals;
1082     a.a_offset = offset;
1083     rc = VCALL(vp, VOFFSET(vop_putpages), &a);
1084     return (rc);
1085 }
1086 struct vop_freeblks_args {
1087     struct vnodeop_desc *a_desc;
1088     struct vnode *a_vp;
1089     daddr_t a_addr;
1090     daddr_t a_length;
1091 };
1092 extern struct vnodeop_desc vop_freeblks_desc;
1093 static __inline int VOP_FREEBLKS
1094 __P((struct vnode * vp, daddr_t addr, daddr_t length));
1095 static __inline int
1096 VOP_FREEBLKS(vp, addr, length)
1097      struct vnode *vp;
1098      daddr_t addr;
1099      daddr_t length;
1100 {
1101     struct vop_freeblks_args a;
1102     int rc;
1103     a.a_desc = VDESC(vop_freeblks);
1104     a.a_vp = vp;
1105     a.a_addr = addr;
1106     a.a_length = length;
1107     rc = VCALL(vp, VOFFSET(vop_freeblks), &a);
1108     return (rc);
1109 }
1110 struct vop_bwrite_args {
1111     struct vnodeop_desc *a_desc;
1112     struct vnode *a_vp;
1113     struct buf *a_bp;
1114 };
1115 extern struct vnodeop_desc vop_bwrite_desc;
1116 static __inline int VOP_BWRITE __P((struct vnode * vp, struct buf * bp));
1117 static __inline int
1118 VOP_BWRITE(vp, bp)
1119      struct vnode *vp;
1120      struct buf *bp;
1121 {
1122     struct vop_bwrite_args a;
1123     int rc;
1124     a.a_desc = VDESC(vop_bwrite);
1125     a.a_vp = vp;
1126     a.a_bp = bp;
1127     rc = VCALL(vp, VOFFSET(vop_bwrite), &a);
1128     return (rc);
1129 }
1130 struct vop_getacl_args {
1131     struct vnodeop_desc *a_desc;
1132     struct vnode *a_vp;
1133     acl_type_t a_type;
1134     struct acl *a_aclp;
1135     struct ucred *a_cred;
1136     struct proc *a_p;
1137 };
1138 extern struct vnodeop_desc vop_getacl_desc;
1139 static __inline int VOP_GETACL
1140 __P((struct vnode * vp, acl_type_t type, struct acl * aclp,
1141      struct ucred * cred, struct proc * p));
1142 static __inline int
1143 VOP_GETACL(vp, type, aclp, cred, p)
1144      struct vnode *vp;
1145      acl_type_t type;
1146      struct acl *aclp;
1147      struct ucred *cred;
1148      struct proc *p;
1149 {
1150     struct vop_getacl_args a;
1151     int rc;
1152     a.a_desc = VDESC(vop_getacl);
1153     a.a_vp = vp;
1154     a.a_type = type;
1155     a.a_aclp = aclp;
1156     a.a_cred = cred;
1157     a.a_p = p;
1158     rc = VCALL(vp, VOFFSET(vop_getacl), &a);
1159     return (rc);
1160 }
1161 struct vop_setacl_args {
1162     struct vnodeop_desc *a_desc;
1163     struct vnode *a_vp;
1164     acl_type_t a_type;
1165     struct acl *a_aclp;
1166     struct ucred *a_cred;
1167     struct proc *a_p;
1168 };
1169 extern struct vnodeop_desc vop_setacl_desc;
1170 static __inline int VOP_SETACL
1171 __P((struct vnode * vp, acl_type_t type, struct acl * aclp,
1172      struct ucred * cred, struct proc * p));
1173 static __inline int
1174 VOP_SETACL(vp, type, aclp, cred, p)
1175      struct vnode *vp;
1176      acl_type_t type;
1177      struct acl *aclp;
1178      struct ucred *cred;
1179      struct proc *p;
1180 {
1181     struct vop_setacl_args a;
1182     int rc;
1183     a.a_desc = VDESC(vop_setacl);
1184     a.a_vp = vp;
1185     a.a_type = type;
1186     a.a_aclp = aclp;
1187     a.a_cred = cred;
1188     a.a_p = p;
1189     rc = VCALL(vp, VOFFSET(vop_setacl), &a);
1190     return (rc);
1191 }
1192 struct vop_aclcheck_args {
1193     struct vnodeop_desc *a_desc;
1194     struct vnode *a_vp;
1195     acl_type_t a_type;
1196     struct acl *a_aclp;
1197     struct ucred *a_cred;
1198     struct proc *a_p;
1199 };
1200 extern struct vnodeop_desc vop_aclcheck_desc;
1201 static __inline int VOP_ACLCHECK
1202 __P((struct vnode * vp, acl_type_t type, struct acl * aclp,
1203      struct ucred * cred, struct proc * p));
1204 static __inline int
1205 VOP_ACLCHECK(vp, type, aclp, cred, p)
1206      struct vnode *vp;
1207      acl_type_t type;
1208      struct acl *aclp;
1209      struct ucred *cred;
1210      struct proc *p;
1211 {
1212     struct vop_aclcheck_args a;
1213     int rc;
1214     a.a_desc = VDESC(vop_aclcheck);
1215     a.a_vp = vp;
1216     a.a_type = type;
1217     a.a_aclp = aclp;
1218     a.a_cred = cred;
1219     a.a_p = p;
1220     rc = VCALL(vp, VOFFSET(vop_aclcheck), &a);
1221     return (rc);
1222 }
1223 struct vop_getextattr_args {
1224     struct vnodeop_desc *a_desc;
1225     struct vnode *a_vp;
1226     char *a_name;
1227     struct uio *a_uio;
1228     struct ucred *a_cred;
1229     struct proc *a_p;
1230 };
1231 extern struct vnodeop_desc vop_getextattr_desc;
1232 static __inline int VOP_GETEXTATTR
1233 __P((struct vnode * vp, char *name, struct uio * uio, struct ucred * cred,
1234      struct proc * p));
1235 static __inline int
1236 VOP_GETEXTATTR(vp, name, uio, cred, p)
1237      struct vnode *vp;
1238      char *name;
1239      struct uio *uio;
1240      struct ucred *cred;
1241      struct proc *p;
1242 {
1243     struct vop_getextattr_args a;
1244     int rc;
1245     a.a_desc = VDESC(vop_getextattr);
1246     a.a_vp = vp;
1247     a.a_name = name;
1248     a.a_uio = uio;
1249     a.a_cred = cred;
1250     a.a_p = p;
1251     rc = VCALL(vp, VOFFSET(vop_getextattr), &a);
1252     return (rc);
1253 }
1254 struct vop_setextattr_args {
1255     struct vnodeop_desc *a_desc;
1256     struct vnode *a_vp;
1257     char *a_name;
1258     struct uio *a_uio;
1259     struct ucred *a_cred;
1260     struct proc *a_p;
1261 };
1262 extern struct vnodeop_desc vop_setextattr_desc;
1263 static __inline int VOP_SETEXTATTR
1264 __P((struct vnode * vp, char *name, struct uio * uio, struct ucred * cred,
1265      struct proc * p));
1266 static __inline int
1267 VOP_SETEXTATTR(vp, name, uio, cred, p)
1268      struct vnode *vp;
1269      char *name;
1270      struct uio *uio;
1271      struct ucred *cred;
1272      struct proc *p;
1273 {
1274     struct vop_setextattr_args a;
1275     int rc;
1276     a.a_desc = VDESC(vop_setextattr);
1277     a.a_vp = vp;
1278     a.a_name = name;
1279     a.a_uio = uio;
1280     a.a_cred = cred;
1281     a.a_p = p;
1282     rc = VCALL(vp, VOFFSET(vop_setextattr), &a);
1283     return (rc);
1284 }
1285 struct vop_createvobject_args {
1286     struct vnodeop_desc *a_desc;
1287     struct vnode *a_vp;
1288     struct ucred *a_cred;
1289     struct proc *a_p;
1290 };
1291 extern struct vnodeop_desc vop_createvobject_desc;
1292 static __inline int VOP_CREATEVOBJECT
1293 __P((struct vnode * vp, struct ucred * cred, struct proc * p));
1294 static __inline int
1295 VOP_CREATEVOBJECT(vp, cred, p)
1296      struct vnode *vp;
1297      struct ucred *cred;
1298      struct proc *p;
1299 {
1300     struct vop_createvobject_args a;
1301     int rc;
1302     a.a_desc = VDESC(vop_createvobject);
1303     a.a_vp = vp;
1304     a.a_cred = cred;
1305     a.a_p = p;
1306     rc = VCALL(vp, VOFFSET(vop_createvobject), &a);
1307     return (rc);
1308 }
1309 struct vop_destroyvobject_args {
1310     struct vnodeop_desc *a_desc;
1311     struct vnode *a_vp;
1312 };
1313 extern struct vnodeop_desc vop_destroyvobject_desc;
1314 static __inline int VOP_DESTROYVOBJECT __P((struct vnode * vp));
1315 static __inline int
1316 VOP_DESTROYVOBJECT(vp)
1317      struct vnode *vp;
1318 {
1319     struct vop_destroyvobject_args a;
1320     int rc;
1321     a.a_desc = VDESC(vop_destroyvobject);
1322     a.a_vp = vp;
1323     rc = VCALL(vp, VOFFSET(vop_destroyvobject), &a);
1324     return (rc);
1325 }
1326 struct vop_getvobject_args {
1327     struct vnodeop_desc *a_desc;
1328     struct vnode *a_vp;
1329     struct vm_object **a_objpp;
1330 };
1331 extern struct vnodeop_desc vop_getvobject_desc;
1332 static __inline int VOP_GETVOBJECT
1333 __P((struct vnode * vp, struct vm_object ** objpp));
1334 static __inline int
1335 VOP_GETVOBJECT(vp, objpp)
1336      struct vnode *vp;
1337      struct vm_object **objpp;
1338 {
1339     struct vop_getvobject_args a;
1340     int rc;
1341     a.a_desc = VDESC(vop_getvobject);
1342     a.a_vp = vp;
1343     a.a_objpp = objpp;
1344     rc = VCALL(vp, VOFFSET(vop_getvobject), &a);
1345     return (rc);
1346 }