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