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.39 2008/06/19 23:27:35 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 VDESCNAME(name) __CONCAT(__CONCAT(vop_,name),_desc)
  79
  80 #define VNODEOP_DESC_INIT(name)                                         \
  81         struct syslink_desc VDESCNAME(name) = {                         \
  82                 __offsetof(struct vop_ops, __CONCAT(vop_, name)),       \
  83                 #name }
  84
  85 VNODEOP_DESC_INIT(default);
  86 VNODEOP_DESC_INIT(old_lookup);
  87 VNODEOP_DESC_INIT(old_create);
  88 VNODEOP_DESC_INIT(old_whiteout);
  89 VNODEOP_DESC_INIT(old_mknod);
  90 VNODEOP_DESC_INIT(open);
  91 VNODEOP_DESC_INIT(close);
  92 VNODEOP_DESC_INIT(access);
  93 VNODEOP_DESC_INIT(getattr);
  94 VNODEOP_DESC_INIT(setattr);
  95 VNODEOP_DESC_INIT(read);
  96 VNODEOP_DESC_INIT(write);
  97 VNODEOP_DESC_INIT(ioctl);
  98 VNODEOP_DESC_INIT(poll);
  99 VNODEOP_DESC_INIT(kqfilter);
 100 VNODEOP_DESC_INIT(mmap);
 101 VNODEOP_DESC_INIT(fsync);
 102 VNODEOP_DESC_INIT(old_remove);
 103 VNODEOP_DESC_INIT(old_link);
 104 VNODEOP_DESC_INIT(old_rename);
 105
 106 VNODEOP_DESC_INIT(old_mkdir);
 107 VNODEOP_DESC_INIT(old_rmdir);
 108 VNODEOP_DESC_INIT(old_symlink);
 109 VNODEOP_DESC_INIT(readdir);
 110 VNODEOP_DESC_INIT(readlink);
 111 VNODEOP_DESC_INIT(inactive);
 112 VNODEOP_DESC_INIT(reclaim);
 113 VNODEOP_DESC_INIT(bmap);
 114 VNODEOP_DESC_INIT(strategy);
 115 VNODEOP_DESC_INIT(print);
 116 VNODEOP_DESC_INIT(pathconf);
 117 VNODEOP_DESC_INIT(advlock);
 118 VNODEOP_DESC_INIT(balloc);
 119 VNODEOP_DESC_INIT(reallocblks);
 120 VNODEOP_DESC_INIT(getpages);
 121 VNODEOP_DESC_INIT(putpages);
 122 VNODEOP_DESC_INIT(freeblks);
 123 VNODEOP_DESC_INIT(getacl);
 124 VNODEOP_DESC_INIT(setacl);
 125 VNODEOP_DESC_INIT(aclcheck);
 126 VNODEOP_DESC_INIT(getextattr);
 127 VNODEOP_DESC_INIT(setextattr);
 128 VNODEOP_DESC_INIT(mountctl);
 129 VNODEOP_DESC_INIT(markatime);
 130
 131 VNODEOP_DESC_INIT(nresolve);
 132 VNODEOP_DESC_INIT(nlookupdotdot);
 133 VNODEOP_DESC_INIT(ncreate);
 134 VNODEOP_DESC_INIT(nmkdir);
 135 VNODEOP_DESC_INIT(nmknod);
 136 VNODEOP_DESC_INIT(nlink);
 137 VNODEOP_DESC_INIT(nsymlink);
 138 VNODEOP_DESC_INIT(nwhiteout);
 139 VNODEOP_DESC_INIT(nremove);
 140 VNODEOP_DESC_INIT(nrmdir);
 141 VNODEOP_DESC_INIT(nrename);
 142
 143 #define DO_OPS(ops, error, ap, vop_field)       \
 144         error = ops->vop_field(ap);
 145
 146 /************************************************************************
 147  *              PRIMARY HIGH LEVEL VNODE OPERATIONS CALLS               *
 148  ************************************************************************
 149  *
 150  * These procedures are called directly from the kernel and/or fileops
 151  * code to perform file/device operations on the system.
 152  *
 153  * NOTE: The old namespace api functions such as vop_rename() are no longer
 154  * available for general use and have been renamed to vop_old_*().  Only
 155  * the code in vfs_default.c is allowed to call those ops.
 156  */
 157
 158 int
 159 vop_old_lookup(struct vop_ops *ops, struct vnode *dvp,
 160         struct vnode **vpp, struct componentname *cnp)
 161 {
 162         struct vop_old_lookup_args ap;
 163         int error;
 164
 165         ap.a_head.a_desc = &vop_old_lookup_desc;
 166         ap.a_head.a_ops = ops;
 167         ap.a_dvp = dvp;
 168         ap.a_vpp = vpp;
 169         ap.a_cnp = cnp;
 170
 171         DO_OPS(ops, error, &ap, vop_old_lookup);
 172         return(error);
 173 }
 174
 175 int
 176 vop_old_create(struct vop_ops *ops, struct vnode *dvp,
 177         struct vnode **vpp, struct componentname *cnp, struct vattr *vap)
 178 {
 179         struct vop_old_create_args ap;
 180         int error;
 181
 182         ap.a_head.a_desc = &vop_old_create_desc;
 183         ap.a_head.a_ops = ops;
 184         ap.a_dvp = dvp;
 185         ap.a_vpp = vpp;
 186         ap.a_cnp = cnp;
 187         ap.a_vap = vap;
 188
 189         DO_OPS(ops, error, &ap, vop_old_create);
 190         return(error);
 191 }
 192
 193 int
 194 vop_old_whiteout(struct vop_ops *ops, struct vnode *dvp,
 195         struct componentname *cnp, int flags)
 196 {
 197         struct vop_old_whiteout_args ap;
 198         int error;
 199
 200         ap.a_head.a_desc = &vop_old_whiteout_desc;
 201         ap.a_head.a_ops = ops;
 202         ap.a_dvp = dvp;
 203         ap.a_cnp = cnp;
 204         ap.a_flags = flags;
 205
 206         DO_OPS(ops, error, &ap, vop_old_whiteout);
 207         return(error);
 208 }
 209
 210 int
 211 vop_old_mknod(struct vop_ops *ops, struct vnode *dvp,
 212         struct vnode **vpp, struct componentname *cnp, struct vattr *vap)
 213 {
 214         struct vop_old_mknod_args ap;
 215         int error;
 216
 217         ap.a_head.a_desc = &vop_old_mknod_desc;
 218         ap.a_head.a_ops = ops;
 219         ap.a_dvp = dvp;
 220         ap.a_vpp = vpp;
 221         ap.a_cnp = cnp;
 222         ap.a_vap = vap;
 223
 224         DO_OPS(ops, error, &ap, vop_old_mknod);
 225         return(error);
 226 }
 227
 228 int
 229 vop_open(struct vop_ops *ops, struct vnode *vp, int mode, struct ucred *cred,
 230         struct file *fp)
 231 {
 232         struct vop_open_args ap;
 233         int error;
 234
 235         ap.a_head.a_desc = &vop_open_desc;
 236         ap.a_head.a_ops = ops;
 237         ap.a_vp = vp;
 238         ap.a_fp = fp;
 239         ap.a_mode = mode;
 240         ap.a_cred = cred;
 241
 242         DO_OPS(ops, error, &ap, vop_open);
 243         return(error);
 244 }
 245
 246 int
 247 vop_close(struct vop_ops *ops, struct vnode *vp, int fflag)
 248 {
 249         struct vop_close_args ap;
 250         int error;
 251
 252         ap.a_head.a_desc = &vop_close_desc;
 253         ap.a_head.a_ops = ops;
 254         ap.a_vp = vp;
 255         ap.a_fflag = fflag;
 256
 257         DO_OPS(ops, error, &ap, vop_close);
 258         return(error);
 259 }
 260
 261 int
 262 vop_access(struct vop_ops *ops, struct vnode *vp, int mode, struct ucred *cred)
 263 {
 264         struct vop_access_args ap;
 265         int error;
 266
 267         ap.a_head.a_desc = &vop_access_desc;
 268         ap.a_head.a_ops = ops;
 269         ap.a_vp = vp;
 270         ap.a_mode = mode;
 271         ap.a_cred = cred;
 272
 273         DO_OPS(ops, error, &ap, vop_access);
 274         return(error);
 275 }
 276
 277 int
 278 vop_getattr(struct vop_ops *ops, struct vnode *vp, struct vattr *vap)
 279 {
 280         struct vop_getattr_args ap;
 281         int error;
 282
 283         ap.a_head.a_desc = &vop_getattr_desc;
 284         ap.a_head.a_ops = ops;
 285         ap.a_vp = vp;
 286         ap.a_vap = vap;
 287
 288         DO_OPS(ops, error, &ap, vop_getattr);
 289
 290         /*
 291          * mount pointer may be NULL if vnode is dead.
 292          */
 293         if (ops->head.vv_mount &&
 294             (ops->head.vv_mount->mnt_kern_flag & MNTK_FSMID) == 0) {
 295                 vap->va_fsmid = cache_sync_fsmid_vp(vp);
 296         }
 297         return(error);
 298 }
 299
 300 int
 301 vop_setattr(struct vop_ops *ops, struct vnode *vp, struct vattr *vap,
 302         struct ucred *cred)
 303 {
 304         struct vop_setattr_args ap;
 305         int error;
 306
 307         ap.a_head.a_desc = &vop_setattr_desc;
 308         ap.a_head.a_ops = ops;
 309         ap.a_vp = vp;
 310         ap.a_vap = vap;
 311         ap.a_cred = cred;
 312
 313         DO_OPS(ops, error, &ap, vop_setattr);
 314         if (error == 0)
 315                 cache_update_fsmid_vp(vp);
 316         return(error);
 317 }
 318
 319 int
 320 vop_read(struct vop_ops *ops, struct vnode *vp, struct uio *uio, int ioflag,
 321         struct ucred *cred)
 322 {
 323         struct vop_read_args ap;
 324         int error;
 325
 326         ap.a_head.a_desc = &vop_read_desc;
 327         ap.a_head.a_ops = ops;
 328         ap.a_vp = vp;
 329         ap.a_uio = uio;
 330         ap.a_ioflag = ioflag;
 331         ap.a_cred = cred;
 332
 333         DO_OPS(ops, error, &ap, vop_read);
 334         return(error);
 335 }
 336
 337 int
 338 vop_write(struct vop_ops *ops, struct vnode *vp, struct uio *uio, int ioflag,
 339         struct ucred *cred)
 340 {
 341         struct vop_write_args ap;
 342         int error;
 343
 344         ap.a_head.a_desc = &vop_write_desc;
 345         ap.a_head.a_ops = ops;
 346         ap.a_vp = vp;
 347         ap.a_uio = uio;
 348         ap.a_ioflag = ioflag;
 349         ap.a_cred = cred;
 350
 351         DO_OPS(ops, error, &ap, vop_write);
 352         if (error == 0)
 353                 cache_update_fsmid_vp(vp);
 354         return(error);
 355 }
 356
 357 int
 358 vop_ioctl(struct vop_ops *ops, struct vnode *vp, u_long command, caddr_t data,
 359         int fflag, struct ucred *cred)
 360 {
 361         struct vop_ioctl_args ap;
 362         int error;
 363
 364         ap.a_head.a_desc = &vop_ioctl_desc;
 365         ap.a_head.a_ops = ops;
 366         ap.a_vp = vp;
 367         ap.a_command = command;
 368         ap.a_data = data;
 369         ap.a_fflag = fflag;
 370         ap.a_cred = cred;
 371
 372         DO_OPS(ops, error, &ap, vop_ioctl);
 373         return(error);
 374 }
 375
 376 int
 377 vop_poll(struct vop_ops *ops, struct vnode *vp, int events, struct ucred *cred)
 378 {
 379         struct vop_poll_args ap;
 380         int error;
 381
 382         ap.a_head.a_desc = &vop_poll_desc;
 383         ap.a_head.a_ops = ops;
 384         ap.a_vp = vp;
 385         ap.a_events = events;
 386         ap.a_cred = cred;
 387
 388         DO_OPS(ops, error, &ap, vop_poll);
 389         return(error);
 390 }
 391
 392 int
 393 vop_kqfilter(struct vop_ops *ops, struct vnode *vp, struct knote *kn)
 394 {
 395         struct vop_kqfilter_args ap;
 396         int error;
 397
 398         ap.a_head.a_desc = &vop_kqfilter_desc;
 399         ap.a_head.a_ops = ops;
 400         ap.a_vp = vp;
 401         ap.a_kn = kn;
 402
 403         DO_OPS(ops, error, &ap, vop_kqfilter);
 404         return(error);
 405 }
 406
 407 int
 408 vop_mmap(struct vop_ops *ops, struct vnode *vp, int fflags, struct ucred *cred)
 409 {
 410         struct vop_mmap_args ap;
 411         int error;
 412
 413         ap.a_head.a_desc = &vop_mmap_desc;
 414         ap.a_head.a_ops = ops;
 415         ap.a_vp = vp;
 416         ap.a_fflags = fflags;
 417         ap.a_cred = cred;
 418
 419         DO_OPS(ops, error, &ap, vop_mmap);
 420         return(error);
 421 }
 422
 423 int
 424 vop_fsync(struct vop_ops *ops, struct vnode *vp, int waitfor)
 425 {
 426         struct vop_fsync_args ap;
 427         int error;
 428
 429         ap.a_head.a_desc = &vop_fsync_desc;
 430         ap.a_head.a_ops = ops;
 431         ap.a_vp = vp;
 432         ap.a_waitfor = waitfor;
 433
 434         DO_OPS(ops, error, &ap, vop_fsync);
 435         return(error);
 436 }
 437
 438 int
 439 vop_old_remove(struct vop_ops *ops, struct vnode *dvp,
 440         struct vnode *vp, struct componentname *cnp)
 441 {
 442         struct vop_old_remove_args ap;
 443         int error;
 444
 445         ap.a_head.a_desc = &vop_old_remove_desc;
 446         ap.a_head.a_ops = ops;
 447         ap.a_dvp = dvp;
 448         ap.a_vp = vp;
 449         ap.a_cnp = cnp;
 450
 451         DO_OPS(ops, error, &ap, vop_old_remove);
 452         return(error);
 453 }
 454
 455 int
 456 vop_old_link(struct vop_ops *ops, struct vnode *tdvp,
 457         struct vnode *vp, struct componentname *cnp)
 458 {
 459         struct vop_old_link_args ap;
 460         int error;
 461
 462         ap.a_head.a_desc = &vop_old_link_desc;
 463         ap.a_head.a_ops = ops;
 464         ap.a_tdvp = tdvp;
 465         ap.a_vp = vp;
 466         ap.a_cnp = cnp;
 467
 468         DO_OPS(ops, error, &ap, vop_old_link);
 469         return(error);
 470 }
 471
 472 int
 473 vop_old_rename(struct vop_ops *ops,
 474            struct vnode *fdvp, struct vnode *fvp, struct componentname *fcnp,
 475            struct vnode *tdvp, struct vnode *tvp, struct componentname *tcnp)
 476 {
 477         struct vop_old_rename_args ap;
 478         int error;
 479
 480         ap.a_head.a_desc = &vop_old_rename_desc;
 481         ap.a_head.a_ops = ops;
 482         ap.a_fdvp = fdvp;
 483         ap.a_fvp = fvp;
 484         ap.a_fcnp = fcnp;
 485         ap.a_tdvp = tdvp;
 486         ap.a_tvp = tvp;
 487         ap.a_tcnp = tcnp;
 488
 489         DO_OPS(ops, error, &ap, vop_old_rename);
 490         return(error);
 491 }
 492
 493 int
 494 vop_old_mkdir(struct vop_ops *ops, struct vnode *dvp,
 495         struct vnode **vpp, struct componentname *cnp, struct vattr *vap)
 496 {
 497         struct vop_old_mkdir_args ap;
 498         int error;
 499
 500         ap.a_head.a_desc = &vop_old_mkdir_desc;
 501         ap.a_head.a_ops = ops;
 502         ap.a_dvp = dvp;
 503         ap.a_vpp = vpp;
 504         ap.a_cnp = cnp;
 505         ap.a_vap = vap;
 506
 507         DO_OPS(ops, error, &ap, vop_old_mkdir);
 508         return(error);
 509 }
 510
 511 int
 512 vop_old_rmdir(struct vop_ops *ops, struct vnode *dvp,
 513         struct vnode *vp, struct componentname *cnp)
 514 {
 515         struct vop_old_rmdir_args ap;
 516         int error;
 517
 518         ap.a_head.a_desc = &vop_old_rmdir_desc;
 519         ap.a_head.a_ops = ops;
 520         ap.a_dvp = dvp;
 521         ap.a_vp = vp;
 522         ap.a_cnp = cnp;
 523
 524         DO_OPS(ops, error, &ap, vop_old_rmdir);
 525         return(error);
 526 }
 527
 528 int
 529 vop_old_symlink(struct vop_ops *ops, struct vnode *dvp,
 530         struct vnode **vpp, struct componentname *cnp,
 531         struct vattr *vap, char *target)
 532 {
 533         struct vop_old_symlink_args ap;
 534         int error;
 535
 536         ap.a_head.a_desc = &vop_old_symlink_desc;
 537         ap.a_head.a_ops = ops;
 538         ap.a_dvp = dvp;
 539         ap.a_vpp = vpp;
 540         ap.a_cnp = cnp;
 541         ap.a_vap = vap;
 542         ap.a_target = target;
 543
 544         DO_OPS(ops, error, &ap, vop_old_symlink);
 545         return(error);
 546 }
 547
 548 int
 549 vop_readdir(struct vop_ops *ops, struct vnode *vp, struct uio *uio,
 550         struct ucred *cred, int *eofflag, int *ncookies, off_t **cookies)
 551 {
 552         struct vop_readdir_args ap;
 553         int error;
 554
 555         ap.a_head.a_desc = &vop_readdir_desc;
 556         ap.a_head.a_ops = ops;
 557         ap.a_vp = vp;
 558         ap.a_uio = uio;
 559         ap.a_cred = cred;
 560         ap.a_eofflag = eofflag;
 561         ap.a_ncookies = ncookies;
 562         ap.a_cookies = cookies;
 563
 564         DO_OPS(ops, error, &ap, vop_readdir);
 565         return(error);
 566 }
 567
 568 int
 569 vop_readlink(struct vop_ops *ops, struct vnode *vp, struct uio *uio,
 570         struct ucred *cred)
 571 {
 572         struct vop_readlink_args ap;
 573         int error;
 574
 575         ap.a_head.a_desc = &vop_readlink_desc;
 576         ap.a_head.a_ops = ops;
 577         ap.a_vp = vp;
 578         ap.a_uio = uio;
 579         ap.a_cred = cred;
 580
 581         DO_OPS(ops, error, &ap, vop_readlink);
 582         return(error);
 583 }
 584
 585 int
 586 vop_inactive(struct vop_ops *ops, struct vnode *vp)
 587 {
 588         struct vop_inactive_args ap;
 589         int error;
 590
 591         ap.a_head.a_desc = &vop_inactive_desc;
 592         ap.a_head.a_ops = ops;
 593         ap.a_vp = vp;
 594
 595         DO_OPS(ops, error, &ap, vop_inactive);
 596         return(error);
 597 }
 598
 599 int
 600 vop_reclaim(struct vop_ops *ops, struct vnode *vp)
 601 {
 602         struct vop_reclaim_args ap;
 603         int error;
 604
 605         ap.a_head.a_desc = &vop_reclaim_desc;
 606         ap.a_head.a_ops = ops;
 607         ap.a_vp = vp;
 608
 609         DO_OPS(ops, error, &ap, vop_reclaim);
 610         return(error);
 611 }
 612
 613 int
 614 vop_bmap(struct vop_ops *ops, struct vnode *vp, off_t loffset,
 615         off_t *doffsetp, int *runp, int *runb, buf_cmd_t cmd)
 616 {
 617         struct vop_bmap_args ap;
 618         int error;
 619
 620         ap.a_head.a_desc = &vop_bmap_desc;
 621         ap.a_head.a_ops = ops;
 622         ap.a_vp = vp;
 623         ap.a_loffset = loffset;
 624         ap.a_doffsetp = doffsetp;
 625         ap.a_runp = runp;
 626         ap.a_runb = runb;
 627         ap.a_cmd = cmd;
 628
 629         DO_OPS(ops, error, &ap, vop_bmap);
 630         return(error);
 631 }
 632
 633 int
 634 vop_strategy(struct vop_ops *ops, struct vnode *vp, struct bio *bio)
 635 {
 636         struct vop_strategy_args ap;
 637         int error;
 638
 639         ap.a_head.a_desc = &vop_strategy_desc;
 640         ap.a_head.a_ops = ops;
 641         ap.a_vp = vp;
 642         ap.a_bio = bio;
 643
 644         DO_OPS(ops, error, &ap, vop_strategy);
 645         if (error == 0 && bio->bio_buf->b_cmd != BUF_CMD_READ)
 646                 cache_update_fsmid_vp(vp);
 647         return(error);
 648 }
 649
 650 int
 651 vop_print(struct vop_ops *ops, struct vnode *vp)
 652 {
 653         struct vop_print_args ap;
 654         int error;
 655
 656         ap.a_head.a_desc = &vop_print_desc;
 657         ap.a_head.a_ops = ops;
 658         ap.a_vp = vp;
 659
 660         DO_OPS(ops, error, &ap, vop_print);
 661         return(error);
 662 }
 663
 664 int
 665 vop_pathconf(struct vop_ops *ops, struct vnode *vp, int name,
 666         register_t *retval)
 667 {
 668         struct vop_pathconf_args ap;
 669         int error;
 670
 671         ap.a_head.a_desc = &vop_pathconf_desc;
 672         ap.a_head.a_ops = ops;
 673         ap.a_vp = vp;
 674         ap.a_name = name;
 675         ap.a_retval = retval;
 676
 677         DO_OPS(ops, error, &ap, vop_pathconf);
 678         return(error);
 679 }
 680
 681 int
 682 vop_advlock(struct vop_ops *ops, struct vnode *vp, caddr_t id, int op,
 683         struct flock *fl, int flags)
 684 {
 685         struct vop_advlock_args ap;
 686         int error;
 687
 688         ap.a_head.a_desc = &vop_advlock_desc;
 689         ap.a_head.a_ops = ops;
 690         ap.a_vp = vp;
 691         ap.a_id = id;
 692         ap.a_op = op;
 693         ap.a_fl = fl;
 694         ap.a_flags = flags;
 695
 696         DO_OPS(ops, error, &ap, vop_advlock);
 697         return(error);
 698 }
 699
 700 int
 701 vop_balloc(struct vop_ops *ops, struct vnode *vp, off_t startoffset,
 702         int size, struct ucred *cred, int flags,
 703         struct buf **bpp)
 704 {
 705         struct vop_balloc_args ap;
 706         int error;
 707
 708         ap.a_head.a_desc = &vop_balloc_desc;
 709         ap.a_head.a_ops = ops;
 710         ap.a_vp = vp;
 711         ap.a_startoffset = startoffset;
 712         ap.a_size = size;
 713         ap.a_cred = cred;
 714         ap.a_flags = flags;
 715         ap.a_bpp = bpp;
 716
 717         DO_OPS(ops, error, &ap, vop_balloc);
 718         return(error);
 719 }
 720
 721 int
 722 vop_reallocblks(struct vop_ops *ops, struct vnode *vp,
 723         struct cluster_save *buflist)
 724 {
 725         struct vop_reallocblks_args ap;
 726         int error;
 727
 728         ap.a_head.a_desc = &vop_reallocblks_desc;
 729         ap.a_head.a_ops = ops;
 730         ap.a_vp = vp;
 731         ap.a_buflist = buflist;
 732
 733         DO_OPS(ops, error, &ap, vop_reallocblks);
 734         return(error);
 735 }
 736
 737 int
 738 vop_getpages(struct vop_ops *ops, struct vnode *vp, vm_page_t *m, int count,
 739         int reqpage, vm_ooffset_t offset)
 740 {
 741         struct vop_getpages_args ap;
 742         int error;
 743
 744         ap.a_head.a_desc = &vop_getpages_desc;
 745         ap.a_head.a_ops = ops;
 746         ap.a_vp = vp;
 747         ap.a_m = m;
 748         ap.a_count = count;
 749         ap.a_reqpage = reqpage;
 750         ap.a_offset = offset;
 751
 752         DO_OPS(ops, error, &ap, vop_getpages);
 753         return(error);
 754 }
 755
 756 int
 757 vop_putpages(struct vop_ops *ops, struct vnode *vp, vm_page_t *m, int count,
 758         int sync, int *rtvals, vm_ooffset_t offset)
 759 {
 760         struct vop_putpages_args ap;
 761         int error;
 762
 763         ap.a_head.a_desc = &vop_putpages_desc;
 764         ap.a_head.a_ops = ops;
 765         ap.a_vp = vp;
 766         ap.a_m = m;
 767         ap.a_count = count;
 768         ap.a_sync = sync;
 769         ap.a_rtvals = rtvals;
 770         ap.a_offset = offset;
 771
 772         DO_OPS(ops, error, &ap, vop_putpages);
 773         if (error == 0)
 774                 cache_update_fsmid_vp(vp);
 775         return(error);
 776 }
 777
 778 int
 779 vop_freeblks(struct vop_ops *ops, struct vnode *vp, off_t offset, int length)
 780 {
 781         struct vop_freeblks_args ap;
 782         int error;
 783
 784         ap.a_head.a_desc = &vop_freeblks_desc;
 785         ap.a_head.a_ops = ops;
 786         ap.a_vp = vp;
 787         ap.a_offset = offset;
 788         ap.a_length = length;
 789
 790         DO_OPS(ops, error, &ap, vop_freeblks);
 791         return(error);
 792 }
 793
 794 int
 795 vop_getacl(struct vop_ops *ops, struct vnode *vp, acl_type_t type,
 796         struct acl *aclp, struct ucred *cred)
 797 {
 798         struct vop_getacl_args ap;
 799         int error;
 800
 801         ap.a_head.a_desc = &vop_getacl_desc;
 802         ap.a_head.a_ops = ops;
 803         ap.a_vp = vp;
 804         ap.a_type = type;
 805         ap.a_aclp = aclp;
 806         ap.a_cred = cred;
 807
 808         DO_OPS(ops, error, &ap, vop_getacl);
 809         return(error);
 810 }
 811
 812 int
 813 vop_setacl(struct vop_ops *ops, struct vnode *vp, acl_type_t type,
 814         struct acl *aclp, struct ucred *cred)
 815 {
 816         struct vop_setacl_args ap;
 817         int error;
 818
 819         ap.a_head.a_desc = &vop_setacl_desc;
 820         ap.a_head.a_ops = ops;
 821         ap.a_vp = vp;
 822         ap.a_type = type;
 823         ap.a_aclp = aclp;
 824         ap.a_cred = cred;
 825
 826         DO_OPS(ops, error, &ap, vop_setacl);
 827         if (error == 0)
 828                 cache_update_fsmid_vp(vp);
 829         return(error);
 830 }
 831
 832 int
 833 vop_aclcheck(struct vop_ops *ops, struct vnode *vp, acl_type_t type,
 834         struct acl *aclp, struct ucred *cred)
 835 {
 836         struct vop_aclcheck_args ap;
 837         int error;
 838
 839         ap.a_head.a_desc = &vop_aclcheck_desc;
 840         ap.a_head.a_ops = ops;
 841         ap.a_vp = vp;
 842         ap.a_type = type;
 843         ap.a_aclp = aclp;
 844         ap.a_cred = cred;
 845
 846         DO_OPS(ops, error, &ap, vop_aclcheck);
 847         return(error);
 848 }
 849
 850 int
 851 vop_getextattr(struct vop_ops *ops, struct vnode *vp, char *name,
 852         struct uio *uio, struct ucred *cred)
 853 {
 854         struct vop_getextattr_args ap;
 855         int error;
 856
 857         ap.a_head.a_desc = &vop_getextattr_desc;
 858         ap.a_head.a_ops = ops;
 859         ap.a_vp = vp;
 860         ap.a_name = name;
 861         ap.a_uio = uio;
 862         ap.a_cred = cred;
 863
 864         DO_OPS(ops, error, &ap, vop_getextattr);
 865         return(error);
 866 }
 867
 868 int
 869 vop_setextattr(struct vop_ops *ops, struct vnode *vp, char *name,
 870         struct uio *uio, struct ucred *cred)
 871 {
 872         struct vop_setextattr_args ap;
 873         int error;
 874
 875         ap.a_head.a_desc = &vop_setextattr_desc;
 876         ap.a_head.a_ops = ops;
 877         ap.a_vp = vp;
 878         ap.a_name = name;
 879         ap.a_uio = uio;
 880         ap.a_cred = cred;
 881
 882         DO_OPS(ops, error, &ap, vop_setextattr);
 883         if (error == 0)
 884                 cache_update_fsmid_vp(vp);
 885         return(error);
 886 }
 887
 888 int
 889 vop_mountctl(struct vop_ops *ops, int op, struct file *fp,
 890         const void *ctl, int ctllen, void *buf, int buflen, int *res)
 891 {
 892         struct vop_mountctl_args ap;
 893         int error;
 894
 895         ap.a_head.a_desc = &vop_mountctl_desc;
 896         ap.a_head.a_ops = ops;
 897         ap.a_op = op;
 898         ap.a_ctl = ctl;
 899         ap.a_fp = fp;
 900         ap.a_ctllen = ctllen;
 901         ap.a_buf = buf;
 902         ap.a_buflen = buflen;
 903         ap.a_res = res;
 904
 905         DO_OPS(ops, error, &ap, vop_mountctl);
 906         return(error);
 907 }
 908
 909 int
 910 vop_markatime(struct vop_ops *ops, struct vnode *vp, struct ucred *cred)
 911 {
 912         struct vop_markatime_args ap;
 913         int error;
 914
 915         ap.a_head.a_desc = &vop_markatime_desc;
 916         ap.a_head.a_ops = ops;
 917         ap.a_vp = vp;
 918         ap.a_cred = cred;
 919
 920         DO_OPS(ops, error, &ap, vop_markatime);
 921         return(error);
 922 }
 923
 924 /*
 925  * NEW API FUNCTIONS
 926  *
 927  * nresolve takes a locked ncp, a referenced but unlocked dvp, and a cred,
 928  * and resolves the ncp into a positive or negative hit.
 929  *
 930  * The namecache is automatically adjusted by this function.  The ncp
 931  * is left locked on return.
 932  */
 933 int
 934 vop_nresolve(struct vop_ops *ops, struct nchandle *nch,
 935              struct vnode *dvp, struct ucred *cred)
 936 {
 937         struct vop_nresolve_args ap;
 938         int error;
 939
 940         ap.a_head.a_desc = &vop_nresolve_desc;
 941         ap.a_head.a_ops = ops;
 942         ap.a_nch = nch;
 943         ap.a_dvp = dvp;
 944         ap.a_cred = cred;
 945
 946         DO_OPS(ops, error, &ap, vop_nresolve);
 947         return(error);
 948 }
 949
 950 /*
 951  * nlookupdotdot takes an unlocked directory, referenced dvp, and looks
 952  * up "..", returning a locked parent directory in *vpp.  If an error
 953  * occurs *vpp will be NULL.
 954  */
 955 int
 956 vop_nlookupdotdot(struct vop_ops *ops, struct vnode *dvp,
 957         struct vnode **vpp, struct ucred *cred, char **fakename)
 958 {
 959         struct vop_nlookupdotdot_args ap;
 960         int error;
 961
 962         ap.a_head.a_desc = &vop_nlookupdotdot_desc;
 963         ap.a_head.a_ops = ops;
 964         ap.a_dvp = dvp;
 965         ap.a_vpp = vpp;
 966         ap.a_cred = cred;
 967         ap.a_fakename = fakename;
 968
 969         DO_OPS(ops, error, &ap, vop_nlookupdotdot);
 970         return(error);
 971 }
 972
 973 /*
 974  * ncreate takes a locked, resolved ncp that typically represents a negative
 975  * cache hit and creates the file or node specified by the ncp, cred, and
 976  * vattr.  If no error occurs a locked vnode is returned in *vpp.
 977  *
 978  * The dvp passed in is referenced but unlocked.
 979  *
 980  * The namecache is automatically adjusted by this function.  The ncp
 981  * is left locked on return.
 982  */
 983 int
 984 vop_ncreate(struct vop_ops *ops, struct nchandle *nch, struct vnode *dvp,
 985         struct vnode **vpp, struct ucred *cred, struct vattr *vap)
 986 {
 987         struct vop_ncreate_args ap;
 988         int error;
 989
 990         ap.a_head.a_desc = &vop_ncreate_desc;
 991         ap.a_head.a_ops = ops;
 992         ap.a_nch = nch;
 993         ap.a_dvp = dvp;
 994         ap.a_vpp = vpp;
 995         ap.a_cred = cred;
 996         ap.a_vap = vap;
 997
 998         DO_OPS(ops, error, &ap, vop_ncreate);
 999         if (error == 0 && *vpp)
1000                 cache_update_fsmid_vp(*vpp);
1001         return(error);
1002 }
1003
1004 /*
1005  * nmkdir takes a locked, resolved ncp that typically represents a negative
1006  * cache hit and creates the directory specified by the ncp, cred, and
1007  * vattr.  If no error occurs a locked vnode is returned in *vpp.
1008  *
1009  * The dvp passed in is referenced but unlocked.
1010  *
1011  * The namecache is automatically adjusted by this function.  The ncp
1012  * is left locked on return.
1013  */
1014 int
1015 vop_nmkdir(struct vop_ops *ops, struct nchandle *nch, struct vnode *dvp,
1016         struct vnode **vpp, struct ucred *cred, struct vattr *vap)
1017 {
1018         struct vop_nmkdir_args ap;
1019         int error;
1020
1021         ap.a_head.a_desc = &vop_nmkdir_desc;
1022         ap.a_head.a_ops = ops;
1023         ap.a_nch = nch;
1024         ap.a_dvp = dvp;
1025         ap.a_vpp = vpp;
1026         ap.a_cred = cred;
1027         ap.a_vap = vap;
1028
1029         DO_OPS(ops, error, &ap, vop_nmkdir);
1030         if (error == 0 && *vpp)
1031                 cache_update_fsmid_vp(*vpp);
1032         return(error);
1033 }
1034
1035 /*
1036  * nmknod takes a locked, resolved ncp that typically represents a negative
1037  * cache hit and creates the node specified by the ncp, cred, and
1038  * vattr.  If no error occurs a locked vnode is returned in *vpp.
1039  *
1040  * The dvp passed in is referenced but unlocked.
1041  *
1042  * The namecache is automatically adjusted by this function.  The ncp
1043  * is left locked on return.
1044  */
1045 int
1046 vop_nmknod(struct vop_ops *ops, struct nchandle *nch, struct vnode *dvp,
1047         struct vnode **vpp, struct ucred *cred, struct vattr *vap)
1048 {
1049         struct vop_nmknod_args ap;
1050         int error;
1051
1052         ap.a_head.a_desc = &vop_nmknod_desc;
1053         ap.a_head.a_ops = ops;
1054         ap.a_nch = nch;
1055         ap.a_dvp = dvp;
1056         ap.a_vpp = vpp;
1057         ap.a_cred = cred;
1058         ap.a_vap = vap;
1059
1060         DO_OPS(ops, error, &ap, vop_nmknod);
1061         if (error == 0 && *vpp)
1062                 cache_update_fsmid_vp(*vpp);
1063         return(error);
1064 }
1065
1066 /*
1067  * nlink takes a locked, resolved ncp that typically represents a negative
1068  * cache hit and creates the node specified by the ncp, cred, and
1069  * existing vnode.  The passed vp must be locked and will remain locked
1070  * on return, as does the ncp, whether an error occurs or not.
1071  *
1072  * The dvp passed in is referenced but unlocked.
1073  *
1074  * The namecache is automatically adjusted by this function.  The ncp
1075  * is left locked on return.
1076  */
1077 int
1078 vop_nlink(struct vop_ops *ops, struct nchandle *nch, struct vnode *dvp,
1079           struct vnode *vp, struct ucred *cred)
1080 {
1081         struct vop_nlink_args ap;
1082         int error;
1083
1084         ap.a_head.a_desc = &vop_nlink_desc;
1085         ap.a_head.a_ops = ops;
1086         ap.a_nch = nch;
1087         ap.a_dvp = dvp;
1088         ap.a_vp = vp;
1089         ap.a_cred = cred;
1090
1091         DO_OPS(ops, error, &ap, vop_nlink);
1092         if (error == 0)
1093                 cache_update_fsmid(nch);
1094         return(error);
1095 }
1096
1097 /*
1098  * nsymlink takes a locked, resolved ncp that typically represents a negative
1099  * cache hit and creates a symbolic link based on cred, vap, and target (the
1100  * contents of the link).  If no error occurs a locked vnode is returned in
1101  * *vpp.
1102  *
1103  * The dvp passed in is referenced but unlocked.
1104  *
1105  * The namecache is automatically adjusted by this function.  The ncp
1106  * is left locked on return.
1107  */
1108 int
1109 vop_nsymlink(struct vop_ops *ops, struct nchandle *nch, struct vnode *dvp,
1110         struct vnode **vpp, struct ucred *cred,
1111         struct vattr *vap, char *target)
1112 {
1113         struct vop_nsymlink_args ap;
1114         int error;
1115
1116         ap.a_head.a_desc = &vop_nsymlink_desc;
1117         ap.a_head.a_ops = ops;
1118         ap.a_nch = nch;
1119         ap.a_dvp = dvp;
1120         ap.a_vpp = vpp;
1121         ap.a_cred = cred;
1122         ap.a_vap = vap;
1123         ap.a_target = target;
1124
1125         DO_OPS(ops, error, &ap, vop_nsymlink);
1126         if (error == 0)
1127                 cache_update_fsmid(nch);
1128         return(error);
1129 }
1130
1131 /*
1132  * nwhiteout takes a locked, resolved ncp that can represent a positive or
1133  * negative hit and executes the whiteout function specified in flags.
1134  *
1135  * The dvp passed in is referenced but unlocked.
1136  *
1137  * The namecache is automatically adjusted by this function.  The ncp
1138  * is left locked on return.
1139  */
1140 int
1141 vop_nwhiteout(struct vop_ops *ops, struct nchandle *nch, struct vnode *dvp,
1142         struct ucred *cred, int flags)
1143 {
1144         struct vop_nwhiteout_args ap;
1145         int error;
1146
1147         ap.a_head.a_desc = &vop_nwhiteout_desc;
1148         ap.a_head.a_ops = ops;
1149         ap.a_nch = nch;
1150         ap.a_dvp = dvp;
1151         ap.a_cred = cred;
1152         ap.a_flags = flags;
1153
1154         DO_OPS(ops, error, &ap, vop_nwhiteout);
1155         if (error == 0)
1156                 cache_update_fsmid(nch);
1157         return(error);
1158 }
1159
1160 /*
1161  * nremove takes a locked, resolved ncp that generally represents a
1162  * positive hit and removes the file.
1163  *
1164  * The dvp passed in is referenced but unlocked.
1165  *
1166  * The namecache is automatically adjusted by this function.  The ncp
1167  * is left locked on return.
1168  */
1169 int
1170 vop_nremove(struct vop_ops *ops, struct nchandle *nch, struct vnode *dvp,
1171             struct ucred *cred)
1172 {
1173         struct vop_nremove_args ap;
1174         int error;
1175
1176         ap.a_head.a_desc = &vop_nremove_desc;
1177         ap.a_head.a_ops = ops;
1178         ap.a_nch = nch;
1179         ap.a_dvp = dvp;
1180         ap.a_cred = cred;
1181
1182         DO_OPS(ops, error, &ap, vop_nremove);
1183         if (error == 0)
1184                 cache_update_fsmid(nch);
1185         return(error);
1186 }
1187
1188 /*
1189  * nrmdir takes a locked, resolved ncp that generally represents a
1190  * directory and removes the directory.
1191  *
1192  * The dvp passed in is referenced but unlocked.
1193  *
1194  * The namecache is automatically adjusted by this function.  The ncp
1195  * is left locked on return.
1196  */
1197 int
1198 vop_nrmdir(struct vop_ops *ops, struct nchandle *nch, struct vnode *dvp,
1199            struct ucred *cred)
1200 {
1201         struct vop_nrmdir_args ap;
1202         int error;
1203
1204         ap.a_head.a_desc = &vop_nrmdir_desc;
1205         ap.a_head.a_ops = ops;
1206         ap.a_nch = nch;
1207         ap.a_dvp = dvp;
1208         ap.a_cred = cred;
1209
1210         DO_OPS(ops, error, &ap, vop_nrmdir);
1211         if (error == 0)
1212                 cache_update_fsmid(nch);
1213         return(error);
1214 }
1215
1216 /*
1217  * nrename takes TWO locked, resolved ncp's and the cred of the caller
1218  * and renames the source ncp to the target ncp.  The target ncp may
1219  * represent a positive or negative hit.
1220  *
1221  * The fdvp and tdvp passed in are referenced but unlocked.
1222  *
1223  * The namecache is automatically adjusted by this function.  The ncp
1224  * is left locked on return.  The source ncp is typically changed to
1225  * a negative cache hit and the target ncp typically takes on the
1226  * source ncp's underlying file.
1227  */
1228 int
1229 vop_nrename(struct vop_ops *ops,
1230             struct nchandle *fnch, struct nchandle *tnch,
1231             struct vnode *fdvp, struct vnode *tdvp,
1232             struct ucred *cred)
1233 {
1234         struct vop_nrename_args ap;
1235         int error;
1236
1237         ap.a_head.a_desc = &vop_nrename_desc;
1238         ap.a_head.a_ops = ops;
1239         ap.a_fnch = fnch;
1240         ap.a_tnch = tnch;
1241         ap.a_fdvp = fdvp;
1242         ap.a_tdvp = tdvp;
1243         ap.a_cred = cred;
1244
1245         DO_OPS(ops, error, &ap, vop_nrename);
1246         if (error == 0) {
1247                 cache_update_fsmid(fnch);
1248                 cache_update_fsmid(tnch);
1249         }
1250         return(error);
1251 }
1252
1253 /************************************************************************
1254  *              PRIMARY VNODE OPERATIONS FORWARDING CALLS               *
1255  ************************************************************************
1256  *
1257  * These procedures are called from VFSs such as unionfs and nullfs
1258  * when they wish to forward an operation on one VFS to another.  The
1259  * argument structure/message is modified and then directly passed to the
1260  * appropriate routine.  This routines may also be called by initiators
1261  * who have an argument structure in hand rather then discreet arguments.
1262  */
1263 int
1264 vop_vnoperate_ap(struct vop_generic_args *ap)
1265 {
1266         struct vop_ops *ops;
1267         int error;
1268
1269         ops = ap->a_ops;
1270         error = VOCALL(ops, ap);
1271
1272         return (error);
1273 }
1274
1275 /*
1276  * This routine is called by the cache coherency layer to execute the actual
1277  * VFS operation.  If a journaling layer is present we call though it, else
1278  * we call the native VOP functions.
1279  */
1280 int
1281 vop_cache_operate_ap(struct vop_generic_args *ap)
1282 {
1283         struct vop_ops *ops;
1284         int error;
1285
1286         ops = ap->a_ops;
1287         if (ops->head.vv_mount->mnt_vn_journal_ops)
1288                 error = VOCALL(ops->head.vv_mount->mnt_vn_journal_ops, ap);
1289         else
1290                 error = VOCALL(ops->head.vv_mount->mnt_vn_norm_ops, ap);
1291         return (error);
1292 }
1293
1294
1295 /*
1296  * This routine is called by the journaling layer to execute the actual
1297  * VFS operation.
1298  */
1299 int
1300 vop_journal_operate_ap(struct vop_generic_args *ap)
1301 {
1302         struct vop_ops *ops;
1303         int error;
1304
1305         ops = ap->a_ops;
1306         error = VOCALL(ops->head.vv_mount->mnt_vn_norm_ops, ap);
1307
1308         return (error);
1309 }
1310
1311 int
1312 vop_open_ap(struct vop_open_args *ap)
1313 {
1314         int error;
1315
1316         DO_OPS(ap->a_head.a_ops, error, ap, vop_open);
1317         return(error);
1318 }
1319
1320 int
1321 vop_close_ap(struct vop_close_args *ap)
1322 {
1323         int error;
1324
1325         DO_OPS(ap->a_head.a_ops, error, ap, vop_close);
1326         return(error);
1327 }
1328
1329 int
1330 vop_access_ap(struct vop_access_args *ap)
1331 {
1332         int error;
1333
1334         DO_OPS(ap->a_head.a_ops, error, ap, vop_access);
1335         return(error);
1336 }
1337
1338 int
1339 vop_getattr_ap(struct vop_getattr_args *ap)
1340 {
1341         int error;
1342
1343         DO_OPS(ap->a_head.a_ops, error, ap, vop_getattr);
1344         return(error);
1345 }
1346
1347 int
1348 vop_setattr_ap(struct vop_setattr_args *ap)
1349 {
1350         int error;
1351
1352         DO_OPS(ap->a_head.a_ops, error, ap, vop_setattr);
1353         return(error);
1354 }
1355
1356 int
1357 vop_read_ap(struct vop_read_args *ap)
1358 {
1359         int error;
1360
1361         DO_OPS(ap->a_head.a_ops, error, ap, vop_read);
1362         return(error);
1363 }
1364
1365 int
1366 vop_write_ap(struct vop_write_args *ap)
1367 {
1368         int error;
1369
1370         DO_OPS(ap->a_head.a_ops, error, ap, vop_write);
1371         return(error);
1372 }
1373
1374 int
1375 vop_ioctl_ap(struct vop_ioctl_args *ap)
1376 {
1377         int error;
1378
1379         DO_OPS(ap->a_head.a_ops, error, ap, vop_ioctl);
1380         return(error);
1381 }
1382
1383 int
1384 vop_poll_ap(struct vop_poll_args *ap)
1385 {
1386         int error;
1387
1388         DO_OPS(ap->a_head.a_ops, error, ap, vop_poll);
1389         return(error);
1390 }
1391
1392 int
1393 vop_kqfilter_ap(struct vop_kqfilter_args *ap)
1394 {
1395         int error;
1396
1397         DO_OPS(ap->a_head.a_ops, error, ap, vop_kqfilter);
1398         return(error);
1399 }
1400
1401 int
1402 vop_mmap_ap(struct vop_mmap_args *ap)
1403 {
1404         int error;
1405
1406         DO_OPS(ap->a_head.a_ops, error, ap, vop_mmap);
1407         return(error);
1408 }
1409
1410 int
1411 vop_fsync_ap(struct vop_fsync_args *ap)
1412 {
1413         int error;
1414
1415         DO_OPS(ap->a_head.a_ops, error, ap, vop_fsync);
1416         return(error);
1417 }
1418
1419 int
1420 vop_readdir_ap(struct vop_readdir_args *ap)
1421 {
1422         int error;
1423
1424         DO_OPS(ap->a_head.a_ops, error, ap, vop_readdir);
1425         return(error);
1426 }
1427
1428 int
1429 vop_readlink_ap(struct vop_readlink_args *ap)
1430 {
1431         int error;
1432
1433         DO_OPS(ap->a_head.a_ops, error, ap, vop_readlink);
1434         return(error);
1435 }
1436
1437 int
1438 vop_inactive_ap(struct vop_inactive_args *ap)
1439 {
1440         int error;
1441
1442         DO_OPS(ap->a_head.a_ops, error, ap, vop_inactive);
1443         return(error);
1444 }
1445
1446 int
1447 vop_reclaim_ap(struct vop_reclaim_args *ap)
1448 {
1449         int error;
1450
1451         DO_OPS(ap->a_head.a_ops, error, ap, vop_reclaim);
1452         return(error);
1453 }
1454
1455 int
1456 vop_bmap_ap(struct vop_bmap_args *ap)
1457 {
1458         int error;
1459
1460         DO_OPS(ap->a_head.a_ops, error, ap, vop_bmap);
1461         return(error);
1462 }
1463
1464 int
1465 vop_strategy_ap(struct vop_strategy_args *ap)
1466 {
1467         int error;
1468
1469         DO_OPS(ap->a_head.a_ops, error, ap, vop_strategy);
1470         return(error);
1471 }
1472
1473 int
1474 vop_print_ap(struct vop_print_args *ap)
1475 {
1476         int error;
1477
1478         DO_OPS(ap->a_head.a_ops, error, ap, vop_print);
1479         return(error);
1480 }
1481
1482 int
1483 vop_pathconf_ap(struct vop_pathconf_args *ap)
1484 {
1485         int error;
1486
1487         DO_OPS(ap->a_head.a_ops, error, ap, vop_pathconf);
1488         return(error);
1489 }
1490
1491 int
1492 vop_advlock_ap(struct vop_advlock_args *ap)
1493 {
1494         int error;
1495
1496         DO_OPS(ap->a_head.a_ops, error, ap, vop_advlock);
1497         return(error);
1498 }
1499
1500 int
1501 vop_balloc_ap(struct vop_balloc_args *ap)
1502 {
1503         int error;
1504
1505         DO_OPS(ap->a_head.a_ops, error, ap, vop_balloc);
1506         return(error);
1507 }
1508
1509 int
1510 vop_reallocblks_ap(struct vop_reallocblks_args *ap)
1511 {
1512         int error;
1513
1514         DO_OPS(ap->a_head.a_ops, error, ap, vop_reallocblks);
1515         return(error);
1516 }
1517
1518 int
1519 vop_getpages_ap(struct vop_getpages_args *ap)
1520 {
1521         int error;
1522
1523         DO_OPS(ap->a_head.a_ops, error, ap, vop_getpages);
1524         return(error);
1525 }
1526
1527 int
1528 vop_putpages_ap(struct vop_putpages_args *ap)
1529 {
1530         int error;
1531
1532         DO_OPS(ap->a_head.a_ops, error, ap, vop_putpages);
1533         return(error);
1534 }
1535
1536 int
1537 vop_freeblks_ap(struct vop_freeblks_args *ap)
1538 {
1539         int error;
1540
1541         DO_OPS(ap->a_head.a_ops, error, ap, vop_freeblks);
1542         return(error);
1543 }
1544
1545 int
1546 vop_getacl_ap(struct vop_getacl_args *ap)
1547 {
1548         int error;
1549
1550         DO_OPS(ap->a_head.a_ops, error, ap, vop_getacl);
1551         return(error);
1552 }
1553
1554 int
1555 vop_setacl_ap(struct vop_setacl_args *ap)
1556 {
1557         int error;
1558
1559         DO_OPS(ap->a_head.a_ops, error, ap, vop_setacl);
1560         return(error);
1561 }
1562
1563 int
1564 vop_aclcheck_ap(struct vop_aclcheck_args *ap)
1565 {
1566         int error;
1567
1568         DO_OPS(ap->a_head.a_ops, error, ap, vop_aclcheck);
1569         return(error);
1570 }
1571
1572 int
1573 vop_getextattr_ap(struct vop_getextattr_args *ap)
1574 {
1575         int error;
1576
1577         DO_OPS(ap->a_head.a_ops, error, ap, vop_getextattr);
1578         return(error);
1579 }
1580
1581 int
1582 vop_setextattr_ap(struct vop_setextattr_args *ap)
1583 {
1584         int error;
1585
1586         DO_OPS(ap->a_head.a_ops, error, ap, vop_setextattr);
1587         return(error);
1588 }
1589
1590 int
1591 vop_mountctl_ap(struct vop_mountctl_args *ap)
1592 {
1593         int error;
1594
1595         DO_OPS(ap->a_head.a_ops, error, ap, vop_mountctl);
1596         return(error);
1597 }
1598
1599 int
1600 vop_markatime_ap(struct vop_markatime_args *ap)
1601 {
1602         int error;
1603
1604         DO_OPS(ap->a_head.a_ops, error, ap, vop_markatime);
1605         return(error);
1606 }
1607
1608 int
1609 vop_nresolve_ap(struct vop_nresolve_args *ap)
1610 {
1611         int error;
1612
1613         DO_OPS(ap->a_head.a_ops, error, ap, vop_nresolve);
1614         return(error);
1615 }
1616
1617 int
1618 vop_nlookupdotdot_ap(struct vop_nlookupdotdot_args *ap)
1619 {
1620         int error;
1621
1622         DO_OPS(ap->a_head.a_ops, error, ap, vop_nlookupdotdot);
1623         return(error);
1624 }
1625
1626 int
1627 vop_ncreate_ap(struct vop_ncreate_args *ap)
1628 {
1629         int error;
1630
1631         DO_OPS(ap->a_head.a_ops, error, ap, vop_ncreate);
1632         return(error);
1633 }
1634
1635 int
1636 vop_nmkdir_ap(struct vop_nmkdir_args *ap)
1637 {
1638         int error;
1639
1640         DO_OPS(ap->a_head.a_ops, error, ap, vop_nmkdir);
1641         return(error);
1642 }
1643
1644 int
1645 vop_nmknod_ap(struct vop_nmknod_args *ap)
1646 {
1647         int error;
1648
1649         DO_OPS(ap->a_head.a_ops, error, ap, vop_nmknod);
1650         return(error);
1651 }
1652
1653 int
1654 vop_nlink_ap(struct vop_nlink_args *ap)
1655 {
1656         int error;
1657
1658         DO_OPS(ap->a_head.a_ops, error, ap, vop_nlink);
1659         return(error);
1660 }
1661
1662 int
1663 vop_nsymlink_ap(struct vop_nsymlink_args *ap)
1664 {
1665         int error;
1666
1667         DO_OPS(ap->a_head.a_ops, error, ap, vop_nsymlink);
1668         return(error);
1669 }
1670
1671 int
1672 vop_nwhiteout_ap(struct vop_nwhiteout_args *ap)
1673 {
1674         int error;
1675
1676         DO_OPS(ap->a_head.a_ops, error, ap, vop_nwhiteout);
1677         return(error);
1678 }
1679
1680 int
1681 vop_nremove_ap(struct vop_nremove_args *ap)
1682 {
1683         int error;
1684
1685         DO_OPS(ap->a_head.a_ops, error, ap, vop_nremove);
1686         return(error);
1687 }
1688
1689 int
1690 vop_nrmdir_ap(struct vop_nrmdir_args *ap)
1691 {
1692         int error;
1693
1694         DO_OPS(ap->a_head.a_ops, error, ap, vop_nrmdir);
1695         return(error);
1696 }
1697
1698 int
1699 vop_nrename_ap(struct vop_nrename_args *ap)
1700 {
1701         int error;
1702
1703         DO_OPS(ap->a_head.a_ops, error, ap, vop_nrename);
1704         return(error);
1705 }
1706