sys/kern/vfs_vopops.c

   1 /*
   2  *
   3  * Copyright (c) 2004 The DragonFly Project.  All rights reserved.
   4  *
   5  * This code is derived from software contributed to The DragonFly Project
   6  * by Matthew Dillon <dillon@backplane.com>
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  *
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in
  16  *    the documentation and/or other materials provided with the
  17  *    distribution.
  18  * 3. Neither the name of The DragonFly Project nor the names of its
  19  *    contributors may be used to endorse or promote products derived
  20  *    from this software without specific, prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  23  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  24  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  25  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
  26  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  27  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
  28  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  29  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  30  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  31  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  32  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  *
  35  * $DragonFly: src/sys/kern/vfs_vopops.c,v 1.5 2004/09/26 01:25:52 dillon Exp $
  36  */
  37
  38 #include <sys/param.h>
  39 #include <sys/systm.h>
  40 #include <sys/buf.h>
  41 #include <sys/conf.h>
  42 #include <sys/dirent.h>
  43 #include <sys/domain.h>
  44 #include <sys/eventhandler.h>
  45 #include <sys/fcntl.h>
  46 #include <sys/kernel.h>
  47 #include <sys/kthread.h>
  48 #include <sys/malloc.h>
  49 #include <sys/mbuf.h>
  50 #include <sys/mount.h>
  51 #include <sys/proc.h>
  52 #include <sys/namei.h>
  53 #include <sys/reboot.h>
  54 #include <sys/socket.h>
  55 #include <sys/stat.h>
  56 #include <sys/sysctl.h>
  57 #include <sys/syslog.h>
  58 #include <sys/vmmeter.h>
  59 #include <sys/vnode.h>
  60 #include <sys/vfsops.h>
  61
  62 #include <machine/limits.h>
  63
  64 #include <vm/vm.h>
  65 #include <vm/vm_object.h>
  66 #include <vm/vm_extern.h>
  67 #include <vm/vm_kern.h>
  68 #include <vm/pmap.h>
  69 #include <vm/vm_map.h>
  70 #include <vm/vm_page.h>
  71 #include <vm/vm_pager.h>
  72 #include <vm/vnode_pager.h>
  73 #include <vm/vm_zone.h>
  74
  75 #include <sys/buf2.h>
  76 #include <sys/thread2.h>
  77
  78 #define VOFFNAME(name)  __CONCAT(__CONCAT(vop_,name),_vp_offsets)
  79 #define VDESCNAME(name) __CONCAT(__CONCAT(vop_,name),_desc)
  80 #define VARGSSTRUCT(name) struct __CONCAT(__CONCAT(vop_,name),_args)
  81
  82 #define VNODEOP_DESC_INIT(name, flags, vpoffs, vpp, cred, proc, comp)   \
  83         struct vnodeop_desc VDESCNAME(name) = {                         \
  84                 __offsetof(struct vop_ops, __CONCAT(vop_, name)),       \
  85                 #name, flags, vpoffs, vpp, cred, proc, comp }
  86
  87 #define VNODEOP_DESC_INIT_SIMPLE(name)                                  \
  88         VNODEOP_DESC_INIT(name, 0, NULL,                                \
  89                 VDESC_NO_OFFSET,                                        \
  90                 VDESC_NO_OFFSET,                                        \
  91                 VDESC_NO_OFFSET,                                        \
  92                 VDESC_NO_OFFSET)
  93
  94 #define VNODEOP_DESC_INIT_VP(name)                                      \
  95         static int VOFFNAME(name)[] = {                                 \
  96                 __offsetof(VARGSSTRUCT(name), a_vp),                    \
  97                 VDESC_NO_OFFSET };                                      \
  98         VNODEOP_DESC_INIT(name, 0, VOFFNAME(name),                      \
  99                 VDESC_NO_OFFSET,                                        \
 100                 VDESC_NO_OFFSET,                                        \
 101                 VDESC_NO_OFFSET,                                        \
 102                 VDESC_NO_OFFSET)
 103
 104 #define VNODEOP_DESC_INIT_VP_VPP(name)                                  \
 105         static int VOFFNAME(name)[] = {                                 \
 106                 __offsetof(VARGSSTRUCT(name), a_vp),                    \
 107                 VDESC_NO_OFFSET };                                      \
 108         VNODEOP_DESC_INIT(name, 0, VOFFNAME(name),                      \
 109                 __offsetof(VARGSSTRUCT(name), a_vpp),                   \
 110                 VDESC_NO_OFFSET,                                        \
 111                 VDESC_NO_OFFSET,                                        \
 112                 VDESC_NO_OFFSET)
 113
 114 #define VNODEOP_DESC_INIT_VP_CRED(name)                                 \
 115         static int VOFFNAME(name)[] = {                                 \
 116                 __offsetof(VARGSSTRUCT(name), a_vp),                    \
 117                 VDESC_NO_OFFSET };                                      \
 118         VNODEOP_DESC_INIT(name, 0, VOFFNAME(name),                      \
 119                 VDESC_NO_OFFSET,                                        \
 120                 __offsetof(VARGSSTRUCT(name), a_cred),                  \
 121                 VDESC_NO_OFFSET,                                        \
 122                 VDESC_NO_OFFSET)
 123
 124 #define VNODEOP_DESC_INIT_DVP_VPP_CNP(name)                             \
 125         static int VOFFNAME(name)[] = {                                 \
 126                 __offsetof(VARGSSTRUCT(name), a_dvp),                   \
 127                 VDESC_NO_OFFSET };                                      \
 128         VNODEOP_DESC_INIT(name, 0, VOFFNAME(name),                      \
 129                 __offsetof(VARGSSTRUCT(name), a_vpp),                   \
 130                 VDESC_NO_OFFSET,                                        \
 131                 VDESC_NO_OFFSET,                                        \
 132                 __offsetof(VARGSSTRUCT(name), a_cnp))
 133
 134 #define VNODEOP_DESC_INIT_DVP_CNP(name)                                 \
 135         static int VOFFNAME(name)[] = {                                 \
 136                 __offsetof(VARGSSTRUCT(name), a_dvp),                   \
 137                 VDESC_NO_OFFSET };                                      \
 138         VNODEOP_DESC_INIT(name, 0, VOFFNAME(name),                      \
 139                 VDESC_NO_OFFSET,                                        \
 140                 VDESC_NO_OFFSET,                                        \
 141                 VDESC_NO_OFFSET,                                        \
 142                 __offsetof(VARGSSTRUCT(name), a_cnp))
 143
 144 #define VNODEOP_DESC_INIT_DVP_VP_CNP(name)                              \
 145         static int VOFFNAME(name)[] = {                                 \
 146                 __offsetof(VARGSSTRUCT(name), a_dvp),                   \
 147                 __offsetof(VARGSSTRUCT(name), a_vp),                    \
 148                 VDESC_NO_OFFSET };                                      \
 149         VNODEOP_DESC_INIT(name, 0, VOFFNAME(name),                      \
 150                 VDESC_NO_OFFSET,                                        \
 151                 VDESC_NO_OFFSET,                                        \
 152                 VDESC_NO_OFFSET,                                        \
 153                 __offsetof(VARGSSTRUCT(name), a_cnp))
 154
 155 #define VNODEOP_DESC_INIT_TDVP_VP_CNP(name)                             \
 156         static int VOFFNAME(name)[] = {                                 \
 157                 __offsetof(VARGSSTRUCT(name), a_tdvp),                  \
 158                 __offsetof(VARGSSTRUCT(name), a_vp),                    \
 159                 VDESC_NO_OFFSET };                                      \
 160         VNODEOP_DESC_INIT(name, 0, VOFFNAME(name),                      \
 161                 VDESC_NO_OFFSET,                                        \
 162                 VDESC_NO_OFFSET,                                        \
 163                 VDESC_NO_OFFSET,                                        \
 164                 __offsetof(VARGSSTRUCT(name), a_cnp))
 165
 166 VNODEOP_DESC_INIT_SIMPLE(default);
 167 VNODEOP_DESC_INIT_VP(islocked);
 168 VNODEOP_DESC_INIT_DVP_VPP_CNP(lookup);
 169 VNODEOP_DESC_INIT_DVP_VPP_CNP(cachedlookup);
 170 VNODEOP_DESC_INIT_DVP_VPP_CNP(create);
 171 VNODEOP_DESC_INIT_DVP_CNP(whiteout);
 172 VNODEOP_DESC_INIT_DVP_VPP_CNP(mknod);
 173 VNODEOP_DESC_INIT_VP_CRED(open);
 174 VNODEOP_DESC_INIT_VP(close);
 175 VNODEOP_DESC_INIT_VP_CRED(access);
 176 VNODEOP_DESC_INIT_VP(getattr);
 177 VNODEOP_DESC_INIT_VP_CRED(setattr);
 178 VNODEOP_DESC_INIT_VP_CRED(read);
 179 VNODEOP_DESC_INIT_VP_CRED(write);
 180 VNODEOP_DESC_INIT_VP_CRED(lease);
 181 VNODEOP_DESC_INIT_VP_CRED(ioctl);
 182 VNODEOP_DESC_INIT_VP_CRED(poll);
 183 VNODEOP_DESC_INIT_VP(kqfilter);
 184 VNODEOP_DESC_INIT_VP(revoke);
 185 VNODEOP_DESC_INIT_VP_CRED(mmap);
 186 VNODEOP_DESC_INIT_VP(fsync);
 187 VNODEOP_DESC_INIT_DVP_VP_CNP(remove);
 188 VNODEOP_DESC_INIT_TDVP_VP_CNP(link);
 189
 190 static int VOFFNAME(rename)[] = {
 191         __offsetof(VARGSSTRUCT(rename), a_fdvp),
 192         __offsetof(VARGSSTRUCT(rename), a_fvp),
 193         __offsetof(VARGSSTRUCT(rename), a_tdvp),
 194         __offsetof(VARGSSTRUCT(rename), a_tvp),
 195         VDESC_NO_OFFSET
 196 };
 197 VNODEOP_DESC_INIT(rename,
 198         VDESC_VP0_WILLRELE|VDESC_VP1_WILLRELE|
 199          VDESC_VP2_WILLRELE|VDESC_VP3_WILLRELE|
 200          VDESC_VP2_WILLUNLOCK|VDESC_VP3_WILLUNLOCK, /* tdvp and tvp */
 201         VOFFNAME(rename),
 202         VDESC_NO_OFFSET,
 203         VDESC_NO_OFFSET,
 204         VDESC_NO_OFFSET,
 205         __offsetof(VARGSSTRUCT(rename), a_fcnp));
 206 VNODEOP_DESC_INIT_DVP_VPP_CNP(mkdir);
 207 VNODEOP_DESC_INIT_DVP_VP_CNP(rmdir);
 208 VNODEOP_DESC_INIT_DVP_VPP_CNP(symlink);
 209 VNODEOP_DESC_INIT_VP_CRED(readdir);
 210 VNODEOP_DESC_INIT_VP_CRED(readlink);
 211 VNODEOP_DESC_INIT_VP(inactive);
 212 VNODEOP_DESC_INIT_VP(reclaim);
 213 VNODEOP_DESC_INIT_VP(lock);
 214 VNODEOP_DESC_INIT_VP(unlock);
 215 VNODEOP_DESC_INIT_VP_VPP(bmap);
 216 VNODEOP_DESC_INIT_VP(strategy);
 217 VNODEOP_DESC_INIT_VP(print);
 218 VNODEOP_DESC_INIT_VP(pathconf);
 219 VNODEOP_DESC_INIT_VP(advlock);
 220 VNODEOP_DESC_INIT_VP_CRED(balloc);
 221 VNODEOP_DESC_INIT_VP(reallocblks);
 222 VNODEOP_DESC_INIT_VP(getpages);
 223 VNODEOP_DESC_INIT_VP(putpages);
 224 VNODEOP_DESC_INIT_VP(freeblks);
 225 VNODEOP_DESC_INIT_VP(bwrite);
 226 VNODEOP_DESC_INIT_VP_CRED(getacl);
 227 VNODEOP_DESC_INIT_VP_CRED(setacl);
 228 VNODEOP_DESC_INIT_VP_CRED(aclcheck);
 229 VNODEOP_DESC_INIT_VP_CRED(getextattr);
 230 VNODEOP_DESC_INIT_VP_CRED(setextattr);
 231 VNODEOP_DESC_INIT_VP(createvobject);
 232 VNODEOP_DESC_INIT_VP(destroyvobject);
 233 VNODEOP_DESC_INIT_VP(getvobject);
 234 VNODEOP_DESC_INIT_SIMPLE(vfsset);
 235
 236 /*
 237  * The DO_OPS macro basicallys calls ops->blah(&ap) but is also responsible
 238  * for checking vv_flags and executing additional hook functions.
 239  *
 240  * NOTE: vop_vnoperate_ap() rolls its own DO_OPS equivalent.
 241  */
 242 #define DO_OPS(ops, error, ap, vop_field)                               \
 243         if (ops->vv_flags & VVF_HOOK_MASK) {                            \
 244                 if (ops->vv_flags & VVF_JOURNAL_HOOK)                   \
 245                         error = ops->vv_jops->vop_field(ap);            \
 246                 else                                                    \
 247                         error = 0;                                      \
 248                 if (error == 0)                                         \
 249                         error = ops->vop_field(ap);                     \
 250         } else {                                                        \
 251                 error = ops->vop_field(ap);                             \
 252         }                                                               \
 253
 254
 255 /************************************************************************
 256  *              PRIMARY HIGH LEVEL VNODE OPERATIONS CALLS               *
 257  ************************************************************************
 258  *
 259  * These procedures are called directly from the kernel and/or fileops
 260  * code to perform file/device operations on the system.
 261  */
 262
 263 int
 264 vop_islocked(struct vop_ops *ops, struct vnode *vp, struct thread *td)
 265 {
 266         struct vop_islocked_args ap;
 267         int error;
 268
 269         ap.a_head.a_desc = &vop_islocked_desc;
 270         ap.a_head.a_ops = ops;
 271         ap.a_vp = vp;
 272         ap.a_td = td;
 273
 274         DO_OPS(ops, error, &ap, vop_islocked);
 275         return(error);
 276 }
 277
 278 int
 279 vop_lookup(struct vop_ops *ops, struct vnode *dvp,
 280         struct namecache *par, struct vnode **vpp,
 281         struct namecache **ncpp, struct componentname *cnp)
 282 {
 283         struct vop_lookup_args ap;
 284         int error;
 285
 286         ap.a_head.a_desc = &vop_lookup_desc;
 287         ap.a_head.a_ops = ops;
 288         ap.a_dvp = dvp;
 289         ap.a_par = par;
 290         ap.a_vpp = vpp;
 291         ap.a_ncpp = ncpp;
 292         ap.a_cnp = cnp;
 293
 294         DO_OPS(ops, error, &ap, vop_lookup);
 295         return(error);
 296 }
 297
 298 int
 299 vop_cachedlookup(struct vop_ops *ops, struct vnode *dvp,
 300         struct vnode **vpp, struct componentname *cnp)
 301 {
 302         struct vop_cachedlookup_args ap;
 303         int error;
 304
 305         ap.a_head.a_desc = &vop_cachedlookup_desc;
 306         ap.a_head.a_ops = ops;
 307         ap.a_dvp = dvp;
 308         ap.a_vpp = vpp;
 309         ap.a_cnp = cnp;
 310
 311         DO_OPS(ops, error, &ap, vop_cachedlookup);
 312         return(error);
 313 }
 314
 315 int
 316 vop_create(struct vop_ops *ops, struct vnode *dvp, struct namecache *par,
 317         struct vnode **vpp, struct componentname *cnp, struct vattr *vap)
 318 {
 319         struct vop_create_args ap;
 320         int error;
 321
 322         ap.a_head.a_desc = &vop_create_desc;
 323         ap.a_head.a_ops = ops;
 324         ap.a_dvp = dvp;
 325         ap.a_par = par;
 326         ap.a_vpp = vpp;
 327         ap.a_cnp = cnp;
 328         ap.a_vap = vap;
 329
 330         DO_OPS(ops, error, &ap, vop_create);
 331         return(error);
 332 }
 333
 334 int
 335 vop_whiteout(struct vop_ops *ops, struct vnode *dvp, struct namecache *par,
 336         struct componentname *cnp, int flags)
 337 {
 338         struct vop_whiteout_args ap;
 339         int error;
 340
 341         ap.a_head.a_desc = &vop_whiteout_desc;
 342         ap.a_head.a_ops = ops;
 343         ap.a_dvp = dvp;
 344         ap.a_par = par;
 345         ap.a_cnp = cnp;
 346         ap.a_flags = flags;
 347
 348         DO_OPS(ops, error, &ap, vop_whiteout);
 349         return(error);
 350 }
 351
 352 int
 353 vop_mknod(struct vop_ops *ops, struct vnode *dvp, struct namecache *par,
 354         struct vnode **vpp, struct componentname *cnp, struct vattr *vap)
 355 {
 356         struct vop_mknod_args ap;
 357         int error;
 358
 359         ap.a_head.a_desc = &vop_mknod_desc;
 360         ap.a_head.a_ops = ops;
 361         ap.a_dvp = dvp;
 362         ap.a_par = par;
 363         ap.a_vpp = vpp;
 364         ap.a_cnp = cnp;
 365         ap.a_vap = vap;
 366
 367         DO_OPS(ops, error, &ap, vop_mknod);
 368         return(error);
 369 }
 370
 371 int
 372 vop_open(struct vop_ops *ops, struct vnode *vp, int mode, struct ucred *cred,
 373         struct thread *td)
 374 {
 375         struct vop_open_args ap;
 376         int error;
 377
 378         ap.a_head.a_desc = &vop_open_desc;
 379         ap.a_head.a_ops = ops;
 380         ap.a_vp = vp;
 381         ap.a_mode = mode;
 382         ap.a_cred = cred;
 383         ap.a_td = td;
 384
 385         DO_OPS(ops, error, &ap, vop_open);
 386         return(error);
 387 }
 388
 389 int
 390 vop_close(struct vop_ops *ops, struct vnode *vp, int fflag, struct thread *td)
 391 {
 392         struct vop_close_args ap;
 393         int error;
 394
 395         ap.a_head.a_desc = &vop_close_desc;
 396         ap.a_head.a_ops = ops;
 397         ap.a_vp = vp;
 398         ap.a_fflag = fflag;
 399         ap.a_td = td;
 400
 401         DO_OPS(ops, error, &ap, vop_close);
 402         return(error);
 403 }
 404
 405 int
 406 vop_access(struct vop_ops *ops, struct vnode *vp, int mode, struct ucred *cred,
 407         struct thread *td)
 408 {
 409         struct vop_access_args ap;
 410         int error;
 411
 412         ap.a_head.a_desc = &vop_access_desc;
 413         ap.a_head.a_ops = ops;
 414         ap.a_vp = vp;
 415         ap.a_mode = mode;
 416         ap.a_cred = cred;
 417         ap.a_td = td;
 418
 419         DO_OPS(ops, error, &ap, vop_access);
 420         return(error);
 421 }
 422
 423 int
 424 vop_getattr(struct vop_ops *ops, struct vnode *vp, struct vattr *vap,
 425         struct thread *td)
 426 {
 427         struct vop_getattr_args ap;
 428         int error;
 429
 430         ap.a_head.a_desc = &vop_getattr_desc;
 431         ap.a_head.a_ops = ops;
 432         ap.a_vp = vp;
 433         ap.a_vap = vap;
 434         ap.a_td = td;
 435
 436         DO_OPS(ops, error, &ap, vop_getattr);
 437         return(error);
 438 }
 439
 440 int
 441 vop_setattr(struct vop_ops *ops, struct vnode *vp, struct vattr *vap,
 442         struct ucred *cred, struct thread *td)
 443 {
 444         struct vop_setattr_args ap;
 445         int error;
 446
 447         ap.a_head.a_desc = &vop_setattr_desc;
 448         ap.a_head.a_ops = ops;
 449         ap.a_vp = vp;
 450         ap.a_vap = vap;
 451         ap.a_cred = cred;
 452         ap.a_td = td;
 453
 454         DO_OPS(ops, error, &ap, vop_setattr);
 455         return(error);
 456 }
 457
 458 int
 459 vop_read(struct vop_ops *ops, struct vnode *vp, struct uio *uio, int ioflag,
 460         struct ucred *cred)
 461 {
 462         struct vop_read_args ap;
 463         int error;
 464
 465         ap.a_head.a_desc = &vop_read_desc;
 466         ap.a_head.a_ops = ops;
 467         ap.a_vp = vp;
 468         ap.a_uio = uio;
 469         ap.a_ioflag = ioflag;
 470         ap.a_cred = cred;
 471
 472         DO_OPS(ops, error, &ap, vop_read);
 473         return(error);
 474 }
 475
 476 int
 477 vop_write(struct vop_ops *ops, struct vnode *vp, struct uio *uio, int ioflag,
 478         struct ucred *cred)
 479 {
 480         struct vop_write_args ap;
 481         int error;
 482
 483         ap.a_head.a_desc = &vop_write_desc;
 484         ap.a_head.a_ops = ops;
 485         ap.a_vp = vp;
 486         ap.a_uio = uio;
 487         ap.a_ioflag = ioflag;
 488         ap.a_cred = cred;
 489
 490         DO_OPS(ops, error, &ap, vop_write);
 491         return(error);
 492 }
 493
 494 int
 495 vop_lease(struct vop_ops *ops, struct vnode *vp, struct thread *td,
 496         struct ucred *cred, int flag)
 497 {
 498         struct vop_lease_args ap;
 499         int error;
 500
 501         ap.a_head.a_desc = &vop_lease_desc;
 502         ap.a_head.a_ops = ops;
 503         ap.a_vp = vp;
 504         ap.a_td = td;
 505         ap.a_cred = cred;
 506         ap.a_flag = flag;
 507
 508         DO_OPS(ops, error, &ap, vop_lease);
 509         return(error);
 510 }
 511
 512 int
 513 vop_ioctl(struct vop_ops *ops, struct vnode *vp, u_long command, caddr_t data,
 514         int fflag, struct ucred *cred,
 515         struct thread *td)
 516 {
 517         struct vop_ioctl_args ap;
 518         int error;
 519
 520         ap.a_head.a_desc = &vop_ioctl_desc;
 521         ap.a_head.a_ops = ops;
 522         ap.a_vp = vp;
 523         ap.a_command = command;
 524         ap.a_data = data;
 525         ap.a_fflag = fflag;
 526         ap.a_cred = cred;
 527         ap.a_td = td;
 528
 529         DO_OPS(ops, error, &ap, vop_ioctl);
 530         return(error);
 531 }
 532
 533 int
 534 vop_poll(struct vop_ops *ops, struct vnode *vp, int events, struct ucred *cred,
 535         struct thread *td)
 536 {
 537         struct vop_poll_args ap;
 538         int error;
 539
 540         ap.a_head.a_desc = &vop_poll_desc;
 541         ap.a_head.a_ops = ops;
 542         ap.a_vp = vp;
 543         ap.a_events = events;
 544         ap.a_cred = cred;
 545         ap.a_td = td;
 546
 547         DO_OPS(ops, error, &ap, vop_poll);
 548         return(error);
 549 }
 550
 551 int
 552 vop_kqfilter(struct vop_ops *ops, struct vnode *vp, struct knote *kn)
 553 {
 554         struct vop_kqfilter_args ap;
 555         int error;
 556
 557         ap.a_head.a_desc = &vop_kqfilter_desc;
 558         ap.a_head.a_ops = ops;
 559         ap.a_vp = vp;
 560         ap.a_kn = kn;
 561
 562         DO_OPS(ops, error, &ap, vop_kqfilter);
 563         return(error);
 564 }
 565
 566 int
 567 vop_revoke(struct vop_ops *ops, struct vnode *vp, int flags)
 568 {
 569         struct vop_revoke_args ap;
 570         int error;
 571
 572         ap.a_head.a_desc = &vop_revoke_desc;
 573         ap.a_head.a_ops = ops;
 574         ap.a_vp = vp;
 575         ap.a_flags = flags;
 576
 577         DO_OPS(ops, error, &ap, vop_revoke);
 578         return(error);
 579 }
 580
 581 int
 582 vop_mmap(struct vop_ops *ops, struct vnode *vp, int fflags, struct ucred *cred,
 583         struct thread *td)
 584 {
 585         struct vop_mmap_args ap;
 586         int error;
 587
 588         ap.a_head.a_desc = &vop_mmap_desc;
 589         ap.a_head.a_ops = ops;
 590         ap.a_vp = vp;
 591         ap.a_fflags = fflags;
 592         ap.a_cred = cred;
 593         ap.a_td = td;
 594
 595         DO_OPS(ops, error, &ap, vop_mmap);
 596         return(error);
 597 }
 598
 599 int
 600 vop_fsync(struct vop_ops *ops, struct vnode *vp, int waitfor, struct thread *td)
 601 {
 602         struct vop_fsync_args ap;
 603         int error;
 604
 605         ap.a_head.a_desc = &vop_fsync_desc;
 606         ap.a_head.a_ops = ops;
 607         ap.a_vp = vp;
 608         ap.a_waitfor = waitfor;
 609         ap.a_td = td;
 610
 611         DO_OPS(ops, error, &ap, vop_fsync);
 612         return(error);
 613 }
 614
 615 int
 616 vop_remove(struct vop_ops *ops, struct vnode *dvp, struct namecache *par,
 617         struct vnode *vp, struct componentname *cnp)
 618 {
 619         struct vop_remove_args ap;
 620         int error;
 621
 622         ap.a_head.a_desc = &vop_remove_desc;
 623         ap.a_head.a_ops = ops;
 624         ap.a_dvp = dvp;
 625         ap.a_par = par;
 626         ap.a_vp = vp;
 627         ap.a_cnp = cnp;
 628
 629         DO_OPS(ops, error, &ap, vop_remove);
 630         return(error);
 631 }
 632
 633 int
 634 vop_link(struct vop_ops *ops, struct vnode *tdvp, struct namecache *par,
 635         struct vnode *vp, struct componentname *cnp)
 636 {
 637         struct vop_link_args ap;
 638         int error;
 639
 640         ap.a_head.a_desc = &vop_link_desc;
 641         ap.a_head.a_ops = ops;
 642         ap.a_tdvp = tdvp;
 643         ap.a_par = par;
 644         ap.a_vp = vp;
 645         ap.a_cnp = cnp;
 646
 647         DO_OPS(ops, error, &ap, vop_link);
 648         return(error);
 649 }
 650
 651 int
 652 vop_rename(struct vop_ops *ops, struct vnode *fdvp, struct namecache *fpar,
 653         struct vnode *fvp, struct componentname *fcnp,
 654         struct vnode *tdvp, struct namecache *tpar,
 655         struct vnode *tvp, struct componentname *tcnp)
 656 {
 657         struct vop_rename_args ap;
 658         int error;
 659
 660         ap.a_head.a_desc = &vop_rename_desc;
 661         ap.a_head.a_ops = ops;
 662         ap.a_fdvp = fdvp;
 663         ap.a_fpar = fpar;
 664         ap.a_fvp = fvp;
 665         ap.a_fcnp = fcnp;
 666         ap.a_tdvp = tdvp;
 667         ap.a_tpar = tpar;
 668         ap.a_tvp = tvp;
 669         ap.a_tcnp = tcnp;
 670
 671         DO_OPS(ops, error, &ap, vop_rename);
 672         return(error);
 673 }
 674
 675 int
 676 vop_mkdir(struct vop_ops *ops, struct vnode *dvp, struct namecache *par,
 677         struct vnode **vpp, struct componentname *cnp, struct vattr *vap)
 678 {
 679         struct vop_mkdir_args ap;
 680         int error;
 681
 682         ap.a_head.a_desc = &vop_mkdir_desc;
 683         ap.a_head.a_ops = ops;
 684         ap.a_dvp = dvp;
 685         ap.a_par = par;
 686         ap.a_vpp = vpp;
 687         ap.a_cnp = cnp;
 688         ap.a_vap = vap;
 689
 690         DO_OPS(ops, error, &ap, vop_mkdir);
 691         return(error);
 692 }
 693
 694 int
 695 vop_rmdir(struct vop_ops *ops, struct vnode *dvp, struct namecache *par,
 696         struct vnode *vp, struct componentname *cnp)
 697 {
 698         struct vop_rmdir_args ap;
 699         int error;
 700
 701         ap.a_head.a_desc = &vop_rmdir_desc;
 702         ap.a_head.a_ops = ops;
 703         ap.a_dvp = dvp;
 704         ap.a_par = par;
 705         ap.a_vp = vp;
 706         ap.a_cnp = cnp;
 707
 708         DO_OPS(ops, error, &ap, vop_rmdir);
 709         return(error);
 710 }
 711
 712 int
 713 vop_symlink(struct vop_ops *ops, struct vnode *dvp, struct namecache *par,
 714         struct vnode **vpp, struct componentname *cnp,
 715         struct vattr *vap, char *target)
 716 {
 717         struct vop_symlink_args ap;
 718         int error;
 719
 720         ap.a_head.a_desc = &vop_symlink_desc;
 721         ap.a_head.a_ops = ops;
 722         ap.a_dvp = dvp;
 723         ap.a_par = par;
 724         ap.a_vpp = vpp;
 725         ap.a_cnp = cnp;
 726         ap.a_vap = vap;
 727         ap.a_target = target;
 728
 729         DO_OPS(ops, error, &ap, vop_symlink);
 730         return(error);
 731 }
 732
 733 int
 734 vop_readdir(struct vop_ops *ops, struct vnode *vp, struct uio *uio,
 735         struct ucred *cred, int *eofflag, int *ncookies, u_long **cookies)
 736 {
 737         struct vop_readdir_args ap;
 738         int error;
 739
 740         ap.a_head.a_desc = &vop_readdir_desc;
 741         ap.a_head.a_ops = ops;
 742         ap.a_vp = vp;
 743         ap.a_uio = uio;
 744         ap.a_cred = cred;
 745         ap.a_eofflag = eofflag;
 746         ap.a_ncookies = ncookies;
 747         ap.a_cookies = cookies;
 748
 749         DO_OPS(ops, error, &ap, vop_readdir);
 750         return(error);
 751 }
 752
 753 int
 754 vop_readlink(struct vop_ops *ops, struct vnode *vp, struct uio *uio,
 755         struct ucred *cred)
 756 {
 757         struct vop_readlink_args ap;
 758         int error;
 759
 760         ap.a_head.a_desc = &vop_readlink_desc;
 761         ap.a_head.a_ops = ops;
 762         ap.a_vp = vp;
 763         ap.a_uio = uio;
 764         ap.a_cred = cred;
 765
 766         DO_OPS(ops, error, &ap, vop_readlink);
 767         return(error);
 768 }
 769
 770 int
 771 vop_inactive(struct vop_ops *ops, struct vnode *vp, struct thread *td)
 772 {
 773         struct vop_inactive_args ap;
 774         int error;
 775
 776         ap.a_head.a_desc = &vop_inactive_desc;
 777         ap.a_head.a_ops = ops;
 778         ap.a_vp = vp;
 779         ap.a_td = td;
 780
 781         DO_OPS(ops, error, &ap, vop_inactive);
 782         return(error);
 783 }
 784
 785 int
 786 vop_reclaim(struct vop_ops *ops, struct vnode *vp, struct thread *td)
 787 {
 788         struct vop_reclaim_args ap;
 789         int error;
 790
 791         ap.a_head.a_desc = &vop_reclaim_desc;
 792         ap.a_head.a_ops = ops;
 793         ap.a_vp = vp;
 794         ap.a_td = td;
 795
 796         DO_OPS(ops, error, &ap, vop_reclaim);
 797         return(error);
 798 }
 799
 800 int
 801 vop_lock(struct vop_ops *ops, struct vnode *vp, struct lwkt_tokref *vlock,
 802         int flags, struct thread *td)
 803 {
 804         struct vop_lock_args ap;
 805         int error;
 806
 807         ap.a_head.a_desc = &vop_lock_desc;
 808         ap.a_head.a_ops = ops;
 809         ap.a_vp = vp;
 810         ap.a_vlock = vlock;
 811         ap.a_flags = flags;
 812         ap.a_td = td;
 813
 814         DO_OPS(ops, error, &ap, vop_lock);
 815         return(error);
 816 }
 817
 818 int
 819 vop_unlock(struct vop_ops *ops, struct vnode *vp, struct lwkt_tokref *vlock,
 820         int flags, struct thread *td)
 821 {
 822         struct vop_unlock_args ap;
 823         int error;
 824
 825         ap.a_head.a_desc = &vop_unlock_desc;
 826         ap.a_head.a_ops = ops;
 827         ap.a_vp = vp;
 828         ap.a_vlock = vlock;
 829         ap.a_flags = flags;
 830         ap.a_td = td;
 831
 832         DO_OPS(ops, error, &ap, vop_unlock);
 833         return(error);
 834 }
 835
 836 int
 837 vop_bmap(struct vop_ops *ops, struct vnode *vp, daddr_t bn, struct vnode **vpp,
 838         daddr_t *bnp, int *runp, int *runb)
 839 {
 840         struct vop_bmap_args ap;
 841         int error;
 842
 843         ap.a_head.a_desc = &vop_bmap_desc;
 844         ap.a_head.a_ops = ops;
 845         ap.a_vp = vp;
 846         ap.a_bn = bn;
 847         ap.a_vpp = vpp;
 848         ap.a_bnp = bnp;
 849         ap.a_runp = runp;
 850         ap.a_runb = runb;
 851
 852         DO_OPS(ops, error, &ap, vop_bmap);
 853         return(error);
 854 }
 855
 856 int
 857 vop_strategy(struct vop_ops *ops, struct vnode *vp, struct buf *bp)
 858 {
 859         struct vop_strategy_args ap;
 860         int error;
 861
 862         ap.a_head.a_desc = &vop_strategy_desc;
 863         ap.a_head.a_ops = ops;
 864         ap.a_vp = vp;
 865         ap.a_bp = bp;
 866
 867         DO_OPS(ops, error, &ap, vop_strategy);
 868         return(error);
 869 }
 870
 871 int
 872 vop_print(struct vop_ops *ops, struct vnode *vp)
 873 {
 874         struct vop_print_args ap;
 875         int error;
 876
 877         ap.a_head.a_desc = &vop_print_desc;
 878         ap.a_head.a_ops = ops;
 879         ap.a_vp = vp;
 880
 881         DO_OPS(ops, error, &ap, vop_print);
 882         return(error);
 883 }
 884
 885 int
 886 vop_pathconf(struct vop_ops *ops, struct vnode *vp, int name,
 887         register_t *retval)
 888 {
 889         struct vop_pathconf_args ap;
 890         int error;
 891
 892         ap.a_head.a_desc = &vop_pathconf_desc;
 893         ap.a_head.a_ops = ops;
 894         ap.a_vp = vp;
 895         ap.a_name = name;
 896         ap.a_retval = retval;
 897
 898         DO_OPS(ops, error, &ap, vop_pathconf);
 899         return(error);
 900 }
 901
 902 int
 903 vop_advlock(struct vop_ops *ops, struct vnode *vp, caddr_t id, int op,
 904         struct flock *fl, int flags)
 905 {
 906         struct vop_advlock_args ap;
 907         int error;
 908
 909         ap.a_head.a_desc = &vop_advlock_desc;
 910         ap.a_head.a_ops = ops;
 911         ap.a_vp = vp;
 912         ap.a_id = id;
 913         ap.a_op = op;
 914         ap.a_fl = fl;
 915         ap.a_flags = flags;
 916
 917         DO_OPS(ops, error, &ap, vop_advlock);
 918         return(error);
 919 }
 920
 921 int
 922 vop_balloc(struct vop_ops *ops, struct vnode *vp, off_t startoffset,
 923         int size, struct ucred *cred, int flags,
 924         struct buf **bpp)
 925 {
 926         struct vop_balloc_args ap;
 927         int error;
 928
 929         ap.a_head.a_desc = &vop_balloc_desc;
 930         ap.a_head.a_ops = ops;
 931         ap.a_vp = vp;
 932         ap.a_startoffset = startoffset;
 933         ap.a_size = size;
 934         ap.a_cred = cred;
 935         ap.a_flags = flags;
 936         ap.a_bpp = bpp;
 937
 938         DO_OPS(ops, error, &ap, vop_balloc);
 939         return(error);
 940 }
 941
 942 int
 943 vop_reallocblks(struct vop_ops *ops, struct vnode *vp,
 944         struct cluster_save *buflist)
 945 {
 946         struct vop_reallocblks_args ap;
 947         int error;
 948
 949         ap.a_head.a_desc = &vop_reallocblks_desc;
 950         ap.a_head.a_ops = ops;
 951         ap.a_vp = vp;
 952         ap.a_buflist = buflist;
 953
 954         DO_OPS(ops, error, &ap, vop_reallocblks);
 955         return(error);
 956 }
 957
 958 int
 959 vop_getpages(struct vop_ops *ops, struct vnode *vp, vm_page_t *m, int count,
 960         int reqpage, vm_ooffset_t offset)
 961 {
 962         struct vop_getpages_args ap;
 963         int error;
 964
 965         ap.a_head.a_desc = &vop_getpages_desc;
 966         ap.a_head.a_ops = ops;
 967         ap.a_vp = vp;
 968         ap.a_m = m;
 969         ap.a_count = count;
 970         ap.a_reqpage = reqpage;
 971         ap.a_offset = offset;
 972
 973         DO_OPS(ops, error, &ap, vop_getpages);
 974         return(error);
 975 }
 976
 977 int
 978 vop_putpages(struct vop_ops *ops, struct vnode *vp, vm_page_t *m, int count,
 979         int sync, int *rtvals, vm_ooffset_t offset)
 980 {
 981         struct vop_putpages_args ap;
 982         int error;
 983
 984         ap.a_head.a_desc = &vop_putpages_desc;
 985         ap.a_head.a_ops = ops;
 986         ap.a_vp = vp;
 987         ap.a_m = m;
 988         ap.a_count = count;
 989         ap.a_sync = sync;
 990         ap.a_rtvals = rtvals;
 991         ap.a_offset = offset;
 992
 993         DO_OPS(ops, error, &ap, vop_putpages);
 994         return(error);
 995 }
 996
 997 int
 998 vop_freeblks(struct vop_ops *ops, struct vnode *vp,
 999         daddr_t addr, daddr_t length)
1000 {
1001         struct vop_freeblks_args ap;
1002         int error;
1003
1004         ap.a_head.a_desc = &vop_freeblks_desc;
1005         ap.a_head.a_ops = ops;
1006         ap.a_vp = vp;
1007         ap.a_addr = addr;
1008         ap.a_length = length;
1009
1010         DO_OPS(ops, error, &ap, vop_freeblks);
1011         return(error);
1012 }
1013
1014 int
1015 vop_bwrite(struct vop_ops *ops, struct vnode *vp, struct buf *bp)
1016 {
1017         struct vop_bwrite_args ap;
1018         int error;
1019
1020         ap.a_head.a_desc = &vop_bwrite_desc;
1021         ap.a_head.a_ops = ops;
1022         ap.a_vp = vp;
1023         ap.a_bp = bp;
1024
1025         DO_OPS(ops, error, &ap, vop_bwrite);
1026         return(error);
1027 }
1028
1029 int
1030 vop_getacl(struct vop_ops *ops, struct vnode *vp, acl_type_t type,
1031         struct acl *aclp, struct ucred *cred, struct thread *td)
1032 {
1033         struct vop_getacl_args ap;
1034         int error;
1035
1036         ap.a_head.a_desc = &vop_getacl_desc;
1037         ap.a_head.a_ops = ops;
1038         ap.a_vp = vp;
1039         ap.a_type = type;
1040         ap.a_aclp = aclp;
1041         ap.a_cred = cred;
1042         ap.a_td = td;
1043
1044         DO_OPS(ops, error, &ap, vop_getacl);
1045         return(error);
1046 }
1047
1048 int
1049 vop_setacl(struct vop_ops *ops, struct vnode *vp, acl_type_t type,
1050         struct acl *aclp, struct ucred *cred, struct thread *td)
1051 {
1052         struct vop_setacl_args ap;
1053         int error;
1054
1055         ap.a_head.a_desc = &vop_setacl_desc;
1056         ap.a_head.a_ops = ops;
1057         ap.a_vp = vp;
1058         ap.a_type = type;
1059         ap.a_aclp = aclp;
1060         ap.a_cred = cred;
1061         ap.a_td = td;
1062
1063         DO_OPS(ops, error, &ap, vop_setacl);
1064         return(error);
1065 }
1066
1067 int
1068 vop_aclcheck(struct vop_ops *ops, struct vnode *vp, acl_type_t type,
1069         struct acl *aclp, struct ucred *cred, struct thread *td)
1070 {
1071         struct vop_aclcheck_args ap;
1072         int error;
1073
1074         ap.a_head.a_desc = &vop_aclcheck_desc;
1075         ap.a_head.a_ops = ops;
1076         ap.a_vp = vp;
1077         ap.a_type = type;
1078         ap.a_aclp = aclp;
1079         ap.a_cred = cred;
1080         ap.a_td = td;
1081
1082         DO_OPS(ops, error, &ap, vop_aclcheck);
1083         return(error);
1084 }
1085
1086 int
1087 vop_getextattr(struct vop_ops *ops, struct vnode *vp, char *name,
1088         struct uio *uio, struct ucred *cred, struct thread *td)
1089 {
1090         struct vop_getextattr_args ap;
1091         int error;
1092
1093         ap.a_head.a_desc = &vop_getextattr_desc;
1094         ap.a_head.a_ops = ops;
1095         ap.a_vp = vp;
1096         ap.a_name = name;
1097         ap.a_uio = uio;
1098         ap.a_cred = cred;
1099         ap.a_td = td;
1100
1101         DO_OPS(ops, error, &ap, vop_getextattr);
1102         return(error);
1103 }
1104
1105 int
1106 vop_setextattr(struct vop_ops *ops, struct vnode *vp, char *name,
1107         struct uio *uio, struct ucred *cred, struct thread *td)
1108 {
1109         struct vop_setextattr_args ap;
1110         int error;
1111
1112         ap.a_head.a_desc = &vop_setextattr_desc;
1113         ap.a_head.a_ops = ops;
1114         ap.a_vp = vp;
1115         ap.a_name = name;
1116         ap.a_uio = uio;
1117         ap.a_cred = cred;
1118         ap.a_td = td;
1119
1120         DO_OPS(ops, error, &ap, vop_setextattr);
1121         return(error);
1122 }
1123
1124 int
1125 vop_createvobject(struct vop_ops *ops, struct vnode *vp, struct thread *td)
1126 {
1127         struct vop_createvobject_args ap;
1128         int error;
1129
1130         ap.a_head.a_desc = &vop_createvobject_desc;
1131         ap.a_head.a_ops = ops;
1132         ap.a_vp = vp;
1133         ap.a_td = td;
1134
1135         DO_OPS(ops, error, &ap, vop_createvobject);
1136         return(error);
1137 }
1138
1139 int
1140 vop_destroyvobject(struct vop_ops *ops, struct vnode *vp)
1141 {
1142         struct vop_destroyvobject_args ap;
1143         int error;
1144
1145         ap.a_head.a_desc = &vop_destroyvobject_desc;
1146         ap.a_head.a_ops = ops;
1147         ap.a_vp = vp;
1148
1149         DO_OPS(ops, error, &ap, vop_destroyvobject);
1150         return(error);
1151 }
1152
1153 int
1154 vop_getvobject(struct vop_ops *ops, struct vnode *vp, struct vm_object **objpp)
1155 {
1156         struct vop_getvobject_args ap;
1157         int error;
1158
1159         ap.a_head.a_desc = &vop_getvobject_desc;
1160         ap.a_head.a_ops = ops;
1161         ap.a_vp = vp;
1162         ap.a_objpp = objpp;
1163
1164         DO_OPS(ops, error, &ap, vop_getvobject);
1165         return(error);
1166 }
1167
1168 int
1169 vop_vfsset(struct vop_ops *ops, int op, const char *opstr)
1170 {
1171         struct vop_vfsset_args ap;
1172         int error;
1173
1174         ap.a_head.a_desc = &vop_vfsset_desc;
1175         ap.a_head.a_ops = ops;
1176         ap.a_op = op;
1177         ap.a_opstr = opstr;
1178
1179         DO_OPS(ops, error, &ap, vop_vfsset);
1180         return(error);
1181 }
1182
1183 /************************************************************************
1184  *              PRIMARY VNODE OPERATIONS FORWARDING CALLS               *
1185  ************************************************************************
1186  *
1187  * These procedures are called from VFSs such as unionfs and nullfs
1188  * when they wish to forward an operation on one VFS to another.  The
1189  * argument structure/message is modified and then directly passed to the
1190  * appropriate routine.  This routines may also be called by initiators
1191  * who have an argument structure in hand rather then discreet arguments.
1192  */
1193 int
1194 vop_vnoperate_ap(struct vop_generic_args *ap)
1195 {
1196         struct vop_ops *ops;
1197         int error;
1198
1199         ops = ap->a_ops;
1200         if (ops->vv_flags & VVF_HOOK_MASK) {
1201                 if (ops->vv_flags & VVF_JOURNAL_HOOK)
1202                         error = VOCALL(ops->vv_jops, ap);
1203                 else
1204                         error = 0;
1205                 if (error == 0)
1206                         error = VOCALL(ops, ap);
1207         } else {
1208                 error = VOCALL(ops, ap);
1209         }
1210         return (error);
1211 }
1212
1213 int
1214 vop_islocked_ap(struct vop_islocked_args *ap)
1215 {
1216         int error;
1217
1218         DO_OPS(ap->a_head.a_ops, error, ap, vop_islocked);
1219         return(error);
1220 }
1221
1222 int
1223 vop_lookup_ap(struct vop_lookup_args *ap)
1224 {
1225         int error;
1226
1227         DO_OPS(ap->a_head.a_ops, error, ap, vop_lookup);
1228         return(error);
1229 }
1230
1231 int
1232 vop_cachedlookup_ap(struct vop_cachedlookup_args *ap)
1233 {
1234         int error;
1235
1236         DO_OPS(ap->a_head.a_ops, error, ap, vop_cachedlookup);
1237         return(error);
1238 }
1239
1240 int
1241 vop_create_ap(struct vop_create_args *ap)
1242 {
1243         int error;
1244
1245         DO_OPS(ap->a_head.a_ops, error, ap, vop_create);
1246         return(error);
1247 }
1248
1249 int
1250 vop_whiteout_ap(struct vop_whiteout_args *ap)
1251 {
1252         int error;
1253
1254         DO_OPS(ap->a_head.a_ops, error, ap, vop_whiteout);
1255         return(error);
1256 }
1257
1258 int
1259 vop_mknod_ap(struct vop_mknod_args *ap)
1260 {
1261         int error;
1262
1263         DO_OPS(ap->a_head.a_ops, error, ap, vop_mknod);
1264         return(error);
1265 }
1266
1267 int
1268 vop_open_ap(struct vop_open_args *ap)
1269 {
1270         int error;
1271
1272         DO_OPS(ap->a_head.a_ops, error, ap, vop_open);
1273         return(error);
1274 }
1275
1276 int
1277 vop_close_ap(struct vop_close_args *ap)
1278 {
1279         int error;
1280
1281         DO_OPS(ap->a_head.a_ops, error, ap, vop_close);
1282         return(error);
1283 }
1284
1285 int
1286 vop_access_ap(struct vop_access_args *ap)
1287 {
1288         int error;
1289
1290         DO_OPS(ap->a_head.a_ops, error, ap, vop_access);
1291         return(error);
1292 }
1293
1294 int
1295 vop_getattr_ap(struct vop_getattr_args *ap)
1296 {
1297         int error;
1298
1299         DO_OPS(ap->a_head.a_ops, error, ap, vop_getattr);
1300         return(error);
1301 }
1302
1303 int
1304 vop_setattr_ap(struct vop_setattr_args *ap)
1305 {
1306         int error;
1307
1308         DO_OPS(ap->a_head.a_ops, error, ap, vop_setattr);
1309         return(error);
1310 }
1311
1312 int
1313 vop_read_ap(struct vop_read_args *ap)
1314 {
1315         int error;
1316
1317         DO_OPS(ap->a_head.a_ops, error, ap, vop_read);
1318         return(error);
1319 }
1320
1321 int
1322 vop_write_ap(struct vop_write_args *ap)
1323 {
1324         int error;
1325
1326         DO_OPS(ap->a_head.a_ops, error, ap, vop_write);
1327         return(error);
1328 }
1329
1330 int
1331 vop_lease_ap(struct vop_lease_args *ap)
1332 {
1333         int error;
1334
1335         DO_OPS(ap->a_head.a_ops, error, ap, vop_lease);
1336         return(error);
1337 }
1338
1339 int
1340 vop_ioctl_ap(struct vop_ioctl_args *ap)
1341 {
1342         int error;
1343
1344         DO_OPS(ap->a_head.a_ops, error, ap, vop_ioctl);
1345         return(error);
1346 }
1347
1348 int
1349 vop_poll_ap(struct vop_poll_args *ap)
1350 {
1351         int error;
1352
1353         DO_OPS(ap->a_head.a_ops, error, ap, vop_poll);
1354         return(error);
1355 }
1356
1357 int
1358 vop_kqfilter_ap(struct vop_kqfilter_args *ap)
1359 {
1360         int error;
1361
1362         DO_OPS(ap->a_head.a_ops, error, ap, vop_kqfilter);
1363         return(error);
1364 }
1365
1366 int
1367 vop_revoke_ap(struct vop_revoke_args *ap)
1368 {
1369         int error;
1370
1371         DO_OPS(ap->a_head.a_ops, error, ap, vop_revoke);
1372         return(error);
1373 }
1374
1375 int
1376 vop_mmap_ap(struct vop_mmap_args *ap)
1377 {
1378         int error;
1379
1380         DO_OPS(ap->a_head.a_ops, error, ap, vop_mmap);
1381         return(error);
1382 }
1383
1384 int
1385 vop_fsync_ap(struct vop_fsync_args *ap)
1386 {
1387         int error;
1388
1389         DO_OPS(ap->a_head.a_ops, error, ap, vop_fsync);
1390         return(error);
1391 }
1392
1393 int
1394 vop_remove_ap(struct vop_remove_args *ap)
1395 {
1396         int error;
1397
1398         DO_OPS(ap->a_head.a_ops, error, ap, vop_remove);
1399         return(error);
1400 }
1401
1402 int
1403 vop_link_ap(struct vop_link_args *ap)
1404 {
1405         int error;
1406
1407         DO_OPS(ap->a_head.a_ops, error, ap, vop_link);
1408         return(error);
1409 }
1410
1411 int
1412 vop_rename_ap(struct vop_rename_args *ap)
1413 {
1414         int error;
1415
1416         DO_OPS(ap->a_head.a_ops, error, ap, vop_rename);
1417         return(error);
1418 }
1419
1420 int
1421 vop_mkdir_ap(struct vop_mkdir_args *ap)
1422 {
1423         int error;
1424
1425         DO_OPS(ap->a_head.a_ops, error, ap, vop_mkdir);
1426         return(error);
1427 }
1428
1429 int
1430 vop_rmdir_ap(struct vop_rmdir_args *ap)
1431 {
1432         int error;
1433
1434         DO_OPS(ap->a_head.a_ops, error, ap, vop_rmdir);
1435         return(error);
1436 }
1437
1438 int
1439 vop_symlink_ap(struct vop_symlink_args *ap)
1440 {
1441         int error;
1442
1443         DO_OPS(ap->a_head.a_ops, error, ap, vop_symlink);
1444         return(error);
1445 }
1446
1447 int
1448 vop_readdir_ap(struct vop_readdir_args *ap)
1449 {
1450         int error;
1451
1452         DO_OPS(ap->a_head.a_ops, error, ap, vop_readdir);
1453         return(error);
1454 }
1455
1456 int
1457 vop_readlink_ap(struct vop_readlink_args *ap)
1458 {
1459         int error;
1460
1461         DO_OPS(ap->a_head.a_ops, error, ap, vop_readlink);
1462         return(error);
1463 }
1464
1465 int
1466 vop_inactive_ap(struct vop_inactive_args *ap)
1467 {
1468         int error;
1469
1470         DO_OPS(ap->a_head.a_ops, error, ap, vop_inactive);
1471         return(error);
1472 }
1473
1474 int
1475 vop_reclaim_ap(struct vop_reclaim_args *ap)
1476 {
1477         int error;
1478
1479         DO_OPS(ap->a_head.a_ops, error, ap, vop_reclaim);
1480         return(error);
1481 }
1482
1483 int
1484 vop_lock_ap(struct vop_lock_args *ap)
1485 {
1486         int error;
1487
1488         DO_OPS(ap->a_head.a_ops, error, ap, vop_lock);
1489         return(error);
1490 }
1491
1492 int
1493 vop_unlock_ap(struct vop_unlock_args *ap)
1494 {
1495         int error;
1496
1497         DO_OPS(ap->a_head.a_ops, error, ap, vop_unlock);
1498         return(error);
1499 }
1500
1501 int
1502 vop_bmap_ap(struct vop_bmap_args *ap)
1503 {
1504         int error;
1505
1506         DO_OPS(ap->a_head.a_ops, error, ap, vop_bmap);
1507         return(error);
1508 }
1509
1510 int
1511 vop_strategy_ap(struct vop_strategy_args *ap)
1512 {
1513         int error;
1514
1515         DO_OPS(ap->a_head.a_ops, error, ap, vop_strategy);
1516         return(error);
1517 }
1518
1519 int
1520 vop_print_ap(struct vop_print_args *ap)
1521 {
1522         int error;
1523
1524         DO_OPS(ap->a_head.a_ops, error, ap, vop_print);
1525         return(error);
1526 }
1527
1528 int
1529 vop_pathconf_ap(struct vop_pathconf_args *ap)
1530 {
1531         int error;
1532
1533         DO_OPS(ap->a_head.a_ops, error, ap, vop_pathconf);
1534         return(error);
1535 }
1536
1537 int
1538 vop_advlock_ap(struct vop_advlock_args *ap)
1539 {
1540         int error;
1541
1542         DO_OPS(ap->a_head.a_ops, error, ap, vop_advlock);
1543         return(error);
1544 }
1545
1546 int
1547 vop_balloc_ap(struct vop_balloc_args *ap)
1548 {
1549         int error;
1550
1551         DO_OPS(ap->a_head.a_ops, error, ap, vop_balloc);
1552         return(error);
1553 }
1554
1555 int
1556 vop_reallocblks_ap(struct vop_reallocblks_args *ap)
1557 {
1558         int error;
1559
1560         DO_OPS(ap->a_head.a_ops, error, ap, vop_reallocblks);
1561         return(error);
1562 }
1563
1564 int
1565 vop_getpages_ap(struct vop_getpages_args *ap)
1566 {
1567         int error;
1568
1569         DO_OPS(ap->a_head.a_ops, error, ap, vop_getpages);
1570         return(error);
1571 }
1572
1573 int
1574 vop_putpages_ap(struct vop_putpages_args *ap)
1575 {
1576         int error;
1577
1578         DO_OPS(ap->a_head.a_ops, error, ap, vop_putpages);
1579         return(error);
1580 }
1581
1582 int
1583 vop_freeblks_ap(struct vop_freeblks_args *ap)
1584 {
1585         int error;
1586
1587         DO_OPS(ap->a_head.a_ops, error, ap, vop_freeblks);
1588         return(error);
1589 }
1590
1591 int
1592 vop_bwrite_ap(struct vop_bwrite_args *ap)
1593 {
1594         int error;
1595
1596         DO_OPS(ap->a_head.a_ops, error, ap, vop_bwrite);
1597         return(error);
1598 }
1599
1600 int
1601 vop_getacl_ap(struct vop_getacl_args *ap)
1602 {
1603         int error;
1604
1605         DO_OPS(ap->a_head.a_ops, error, ap, vop_getacl);
1606         return(error);
1607 }
1608
1609 int
1610 vop_setacl_ap(struct vop_setacl_args *ap)
1611 {
1612         int error;
1613
1614         DO_OPS(ap->a_head.a_ops, error, ap, vop_setacl);
1615         return(error);
1616 }
1617
1618 int
1619 vop_aclcheck_ap(struct vop_aclcheck_args *ap)
1620 {
1621         int error;
1622
1623         DO_OPS(ap->a_head.a_ops, error, ap, vop_aclcheck);
1624         return(error);
1625 }
1626
1627 int
1628 vop_getextattr_ap(struct vop_getextattr_args *ap)
1629 {
1630         int error;
1631
1632         DO_OPS(ap->a_head.a_ops, error, ap, vop_getextattr);
1633         return(error);
1634 }
1635
1636 int
1637 vop_setextattr_ap(struct vop_setextattr_args *ap)
1638 {
1639         int error;
1640
1641         DO_OPS(ap->a_head.a_ops, error, ap, vop_setextattr);
1642         return(error);
1643 }
1644
1645 int
1646 vop_createvobject_ap(struct vop_createvobject_args *ap)
1647 {
1648         int error;
1649
1650         DO_OPS(ap->a_head.a_ops, error, ap, vop_createvobject);
1651         return(error);
1652 }
1653
1654 int
1655 vop_destroyvobject_ap(struct vop_destroyvobject_args *ap)
1656 {
1657         int error;
1658
1659         DO_OPS(ap->a_head.a_ops, error, ap, vop_destroyvobject);
1660         return(error);
1661 }
1662
1663 int
1664 vop_getvobject_ap(struct vop_getvobject_args *ap)
1665 {
1666         int error;
1667
1668         DO_OPS(ap->a_head.a_ops, error, ap, vop_getvobject);
1669         return(error);
1670 }
1671
1672 int
1673 vop_vfsset_ap(struct vop_vfsset_args *ap)
1674 {
1675         int error;
1676
1677         DO_OPS(ap->a_head.a_ops, error, ap, vop_vfsset);
1678         return(error);
1679 }
1680