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