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