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