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