src/afs/FBSD/vnode_if_5x.h

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