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