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