1 /* 2 * Copyright (c) 2004,2009 The DragonFly Project. All rights reserved. 3 * 4 * This code is derived from software contributed to The DragonFly Project 5 * by Matthew Dillon <dillon@backplane.com> 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in 15 * the documentation and/or other materials provided with the 16 * distribution. 17 * 3. Neither the name of The DragonFly Project nor the names of its 18 * contributors may be used to endorse or promote products derived 19 * from this software without specific, prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 24 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 25 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 26 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, 27 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 29 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 30 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 31 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 32 * SUCH DAMAGE. 33 */ 34 /* 35 * Implement vnode ops wrappers. All vnode ops are wrapped through 36 * these functions. 37 * 38 * These wrappers are responsible for hanlding all MPSAFE issues related 39 * to a vnode operation. 40 */ 41 42 #include <sys/param.h> 43 #include <sys/systm.h> 44 #include <sys/buf.h> 45 #include <sys/conf.h> 46 #include <sys/dirent.h> 47 #include <sys/domain.h> 48 #include <sys/eventhandler.h> 49 #include <sys/fcntl.h> 50 #include <sys/kernel.h> 51 #include <sys/kthread.h> 52 #include <sys/malloc.h> 53 #include <sys/mbuf.h> 54 #include <sys/mount.h> 55 #include <sys/proc.h> 56 #include <sys/namei.h> 57 #include <sys/reboot.h> 58 #include <sys/socket.h> 59 #include <sys/stat.h> 60 #include <sys/sysctl.h> 61 #include <sys/syslog.h> 62 #include <sys/vmmeter.h> 63 #include <sys/vnode.h> 64 #include <sys/vfsops.h> 65 #include <sys/sysmsg.h> 66 #include <sys/vfs_quota.h> 67 68 #include <machine/limits.h> 69 70 #include <vm/vm.h> 71 #include <vm/vm_object.h> 72 #include <vm/vm_extern.h> 73 #include <vm/vm_kern.h> 74 #include <vm/pmap.h> 75 #include <vm/vm_map.h> 76 #include <vm/vm_page.h> 77 #include <vm/vm_pager.h> 78 #include <vm/vnode_pager.h> 79 #include <vm/vm_zone.h> 80 81 #include <sys/buf2.h> 82 #include <sys/mplock2.h> 83 84 #define VDESCNAME(name) __CONCAT(__CONCAT(vop_,name),_desc) 85 86 #define VNODEOP_DESC_INIT(name) \ 87 struct syslink_desc VDESCNAME(name) = { \ 88 __offsetof(struct vop_ops, __CONCAT(vop_, name)), \ 89 #name } 90 91 VNODEOP_DESC_INIT(default); 92 VNODEOP_DESC_INIT(old_lookup); 93 VNODEOP_DESC_INIT(old_create); 94 VNODEOP_DESC_INIT(old_whiteout); 95 VNODEOP_DESC_INIT(old_mknod); 96 VNODEOP_DESC_INIT(open); 97 VNODEOP_DESC_INIT(close); 98 VNODEOP_DESC_INIT(access); 99 VNODEOP_DESC_INIT(getattr); 100 VNODEOP_DESC_INIT(getattr_lite); 101 VNODEOP_DESC_INIT(setattr); 102 VNODEOP_DESC_INIT(read); 103 VNODEOP_DESC_INIT(write); 104 VNODEOP_DESC_INIT(ioctl); 105 VNODEOP_DESC_INIT(poll); 106 VNODEOP_DESC_INIT(kqfilter); 107 VNODEOP_DESC_INIT(mmap); 108 VNODEOP_DESC_INIT(fsync); 109 VNODEOP_DESC_INIT(old_remove); 110 VNODEOP_DESC_INIT(old_link); 111 VNODEOP_DESC_INIT(old_rename); 112 113 VNODEOP_DESC_INIT(old_mkdir); 114 VNODEOP_DESC_INIT(old_rmdir); 115 VNODEOP_DESC_INIT(old_symlink); 116 VNODEOP_DESC_INIT(readdir); 117 VNODEOP_DESC_INIT(readlink); 118 VNODEOP_DESC_INIT(inactive); 119 VNODEOP_DESC_INIT(reclaim); 120 VNODEOP_DESC_INIT(bmap); 121 VNODEOP_DESC_INIT(strategy); 122 VNODEOP_DESC_INIT(print); 123 VNODEOP_DESC_INIT(pathconf); 124 VNODEOP_DESC_INIT(advlock); 125 VNODEOP_DESC_INIT(balloc); 126 VNODEOP_DESC_INIT(reallocblks); 127 VNODEOP_DESC_INIT(getpages); 128 VNODEOP_DESC_INIT(putpages); 129 VNODEOP_DESC_INIT(freeblks); 130 VNODEOP_DESC_INIT(getacl); 131 VNODEOP_DESC_INIT(setacl); 132 VNODEOP_DESC_INIT(aclcheck); 133 VNODEOP_DESC_INIT(getextattr); 134 VNODEOP_DESC_INIT(setextattr); 135 VNODEOP_DESC_INIT(mountctl); 136 VNODEOP_DESC_INIT(markatime); 137 138 VNODEOP_DESC_INIT(nresolve); 139 VNODEOP_DESC_INIT(nlookupdotdot); 140 VNODEOP_DESC_INIT(ncreate); 141 VNODEOP_DESC_INIT(nmkdir); 142 VNODEOP_DESC_INIT(nmknod); 143 VNODEOP_DESC_INIT(nlink); 144 VNODEOP_DESC_INIT(nsymlink); 145 VNODEOP_DESC_INIT(nwhiteout); 146 VNODEOP_DESC_INIT(nremove); 147 VNODEOP_DESC_INIT(nrmdir); 148 VNODEOP_DESC_INIT(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 161 * longer available for general use and have been renamed to 162 * vop_old_*(). Only the code in vfs_default.c is allowed to call 163 * those ops. 164 * 165 * NOTE: The VFS_MPLOCK() macro handle mounts which do not set MNTK_MPSAFE. 166 * 167 * MPSAFE 168 */ 169 170 int 171 vop_old_lookup(struct vop_ops *ops, struct vnode *dvp, 172 struct vnode **vpp, struct componentname *cnp) 173 { 174 struct vop_old_lookup_args ap; 175 VFS_MPLOCK_DECLARE; 176 int error; 177 178 ap.a_head.a_desc = &vop_old_lookup_desc; 179 ap.a_head.a_ops = ops; 180 ap.a_dvp = dvp; 181 ap.a_vpp = vpp; 182 ap.a_cnp = cnp; 183 VFS_MPLOCK(dvp->v_mount); 184 DO_OPS(ops, error, &ap, vop_old_lookup); 185 VFS_MPUNLOCK(); 186 187 return(error); 188 } 189 190 /* 191 * MPSAFE 192 */ 193 int 194 vop_old_create(struct vop_ops *ops, struct vnode *dvp, 195 struct vnode **vpp, struct componentname *cnp, struct vattr *vap) 196 { 197 struct vop_old_create_args ap; 198 VFS_MPLOCK_DECLARE; 199 int error; 200 201 ap.a_head.a_desc = &vop_old_create_desc; 202 ap.a_head.a_ops = ops; 203 ap.a_dvp = dvp; 204 ap.a_vpp = vpp; 205 ap.a_cnp = cnp; 206 ap.a_vap = vap; 207 208 VFS_MPLOCK(dvp->v_mount); 209 DO_OPS(ops, error, &ap, vop_old_create); 210 VFS_MPUNLOCK(); 211 212 return(error); 213 } 214 215 /* 216 * MPSAFE 217 */ 218 int 219 vop_old_whiteout(struct vop_ops *ops, struct vnode *dvp, 220 struct componentname *cnp, int flags) 221 { 222 struct vop_old_whiteout_args ap; 223 VFS_MPLOCK_DECLARE; 224 int error; 225 226 ap.a_head.a_desc = &vop_old_whiteout_desc; 227 ap.a_head.a_ops = ops; 228 ap.a_dvp = dvp; 229 ap.a_cnp = cnp; 230 ap.a_flags = flags; 231 232 VFS_MPLOCK(dvp->v_mount); 233 DO_OPS(ops, error, &ap, vop_old_whiteout); 234 VFS_MPUNLOCK(); 235 236 return(error); 237 } 238 239 /* 240 * MPSAFE 241 */ 242 int 243 vop_old_mknod(struct vop_ops *ops, struct vnode *dvp, 244 struct vnode **vpp, struct componentname *cnp, struct vattr *vap) 245 { 246 struct vop_old_mknod_args ap; 247 VFS_MPLOCK_DECLARE; 248 int error; 249 250 ap.a_head.a_desc = &vop_old_mknod_desc; 251 ap.a_head.a_ops = ops; 252 ap.a_dvp = dvp; 253 ap.a_vpp = vpp; 254 ap.a_cnp = cnp; 255 ap.a_vap = vap; 256 257 VFS_MPLOCK(dvp->v_mount); 258 DO_OPS(ops, error, &ap, vop_old_mknod); 259 VFS_MPUNLOCK(); 260 261 return(error); 262 } 263 264 /* 265 * NOTE: VAGE is always cleared when calling VOP_OPEN(). 266 */ 267 int 268 vop_open(struct vop_ops *ops, struct vnode *vp, int mode, struct ucred *cred, 269 struct file *fp) 270 { 271 struct vop_open_args ap; 272 VFS_MPLOCK_DECLARE; 273 int error; 274 275 /* 276 * Decrement 3-2-1-0. Does not decrement beyond 0 277 */ 278 if (vp->v_flag & VAGE0) { 279 vclrflags(vp, VAGE0); 280 } else if (vp->v_flag & VAGE1) { 281 vclrflags(vp, VAGE1); 282 vsetflags(vp, VAGE0); 283 } 284 285 ap.a_head.a_desc = &vop_open_desc; 286 ap.a_head.a_ops = ops; 287 ap.a_vp = vp; 288 ap.a_fp = fp; 289 ap.a_mode = mode; 290 ap.a_cred = cred; 291 292 VFS_MPLOCK(vp->v_mount); 293 DO_OPS(ops, error, &ap, vop_open); 294 VFS_MPUNLOCK(); 295 296 return(error); 297 } 298 299 /* 300 * MPSAFE 301 */ 302 int 303 vop_close(struct vop_ops *ops, struct vnode *vp, int fflag, 304 struct file *fp) 305 { 306 struct vop_close_args ap; 307 VFS_MPLOCK_DECLARE; 308 int error; 309 310 ap.a_head.a_desc = &vop_close_desc; 311 ap.a_head.a_ops = ops; 312 ap.a_vp = vp; 313 ap.a_fp = fp; 314 ap.a_fflag = fflag; 315 316 VFS_MPLOCK(vp->v_mount); 317 DO_OPS(ops, error, &ap, vop_close); 318 VFS_MPUNLOCK(); 319 320 return(error); 321 } 322 323 /* 324 * MPSAFE 325 */ 326 int 327 vop_access(struct vop_ops *ops, struct vnode *vp, int mode, int flags, 328 struct ucred *cred) 329 { 330 struct vop_access_args ap; 331 VFS_MPLOCK_DECLARE; 332 int error; 333 334 ap.a_head.a_desc = &vop_access_desc; 335 ap.a_head.a_ops = ops; 336 ap.a_vp = vp; 337 ap.a_mode = mode; 338 ap.a_flags = flags; 339 ap.a_cred = cred; 340 341 VFS_MPLOCK(vp->v_mount); 342 DO_OPS(ops, error, &ap, vop_access); 343 VFS_MPUNLOCK(); 344 345 return(error); 346 } 347 348 /* 349 * MPSAFE 350 */ 351 int 352 vop_getattr(struct vop_ops *ops, struct vnode *vp, struct vattr *vap, 353 struct file *fp) 354 { 355 struct vop_getattr_args ap; 356 VFS_MPLOCK_DECLARE; 357 int error; 358 359 ap.a_head.a_desc = &vop_getattr_desc; 360 ap.a_head.a_ops = ops; 361 ap.a_vp = vp; 362 ap.a_vap = vap; 363 ap.a_fp = fp; 364 365 VFS_MPLOCK_FLAG(vp->v_mount, MNTK_GA_MPSAFE); 366 DO_OPS(ops, error, &ap, vop_getattr); 367 VFS_MPUNLOCK(); 368 369 return(error); 370 } 371 372 /* 373 * MPSAFE 374 */ 375 int 376 vop_getattr_lite(struct vop_ops *ops, struct vnode *vp, struct vattr_lite *lvap) 377 { 378 struct vop_getattr_lite_args ap; 379 VFS_MPLOCK_DECLARE; 380 int error; 381 382 ap.a_head.a_desc = &vop_getattr_lite_desc; 383 ap.a_head.a_ops = ops; 384 ap.a_vp = vp; 385 ap.a_lvap = lvap; 386 ap.a_fp = NULL; 387 388 VFS_MPLOCK_FLAG(vp->v_mount, MNTK_GA_MPSAFE); 389 DO_OPS(ops, error, &ap, vop_getattr_lite); 390 VFS_MPUNLOCK(); 391 392 return(error); 393 } 394 395 /* 396 * MPSAFE 397 */ 398 int 399 vop_setattr(struct vop_ops *ops, struct vnode *vp, struct vattr *vap, 400 struct ucred *cred, struct file *fp) 401 { 402 struct vop_setattr_args ap; 403 VFS_MPLOCK_DECLARE; 404 int error; 405 406 ap.a_head.a_desc = &vop_setattr_desc; 407 ap.a_head.a_ops = ops; 408 ap.a_vp = vp; 409 ap.a_vap = vap; 410 ap.a_cred = cred; 411 ap.a_fp = fp; 412 413 VFS_MPLOCK(vp->v_mount); 414 DO_OPS(ops, error, &ap, vop_setattr); 415 VFS_MPUNLOCK(); 416 417 return(error); 418 } 419 420 /* 421 * MPSAFE 422 */ 423 int 424 vop_read(struct vop_ops *ops, struct vnode *vp, struct uio *uio, int ioflag, 425 struct ucred *cred, struct file *fp) 426 { 427 struct vop_read_args ap; 428 VFS_MPLOCK_DECLARE; 429 int error; 430 431 ap.a_head.a_desc = &vop_read_desc; 432 ap.a_head.a_ops = ops; 433 ap.a_vp = vp; 434 ap.a_uio = uio; 435 ap.a_ioflag = ioflag; 436 ap.a_cred = cred; 437 ap.a_fp = fp; 438 439 VFS_MPLOCK_FLAG(vp->v_mount, MNTK_RD_MPSAFE); 440 DO_OPS(ops, error, &ap, vop_read); 441 VFS_MPUNLOCK(); 442 443 return(error); 444 } 445 446 /* 447 * MPSAFE 448 */ 449 int 450 vop_write(struct vop_ops *ops, struct vnode *vp, struct uio *uio, int ioflag, 451 struct ucred *cred, struct file *fp) 452 { 453 struct vop_write_args ap; 454 VFS_MPLOCK_DECLARE; 455 int error, do_accounting = 0; 456 struct vattr va; 457 uint64_t size_before=0, size_after=0; 458 struct mount *mp; 459 uint64_t offset, delta; 460 461 ap.a_head.a_desc = &vop_write_desc; 462 ap.a_head.a_ops = ops; 463 ap.a_vp = vp; 464 ap.a_uio = uio; 465 ap.a_ioflag = ioflag; 466 ap.a_cred = cred; 467 ap.a_fp = fp; 468 469 /* is this a regular vnode ? */ 470 VFS_MPLOCK_FLAG(vp->v_mount, MNTK_WR_MPSAFE); 471 if (vfs_quota_enabled && (vp->v_type == VREG)) { 472 if ((error = VOP_GETATTR(vp, &va)) != 0) 473 goto done; 474 size_before = va.va_size; 475 /* this file may already have been removed */ 476 if (va.va_nlink > 0) 477 do_accounting = 1; 478 479 offset = uio->uio_offset; 480 if (ioflag & IO_APPEND) 481 offset = size_before; 482 size_after = offset + uio->uio_resid; 483 if (size_after < size_before) 484 size_after = size_before; 485 delta = size_after - size_before; 486 mp = vq_vptomp(vp); 487 /* QUOTA CHECK */ 488 if (!vq_write_ok(mp, va.va_uid, va.va_gid, delta)) { 489 error = EDQUOT; 490 goto done; 491 } 492 } 493 DO_OPS(ops, error, &ap, vop_write); 494 if ((error == 0) && do_accounting) { 495 VFS_ACCOUNT(mp, va.va_uid, va.va_gid, size_after - size_before); 496 } 497 done: 498 VFS_MPUNLOCK(); 499 500 return(error); 501 } 502 503 /* 504 * MPSAFE 505 */ 506 int 507 vop_ioctl(struct vop_ops *ops, struct vnode *vp, u_long command, caddr_t data, 508 int fflag, struct ucred *cred, struct sysmsg *msg) 509 { 510 struct vop_ioctl_args ap; 511 VFS_MPLOCK_DECLARE; 512 int error; 513 514 ap.a_head.a_desc = &vop_ioctl_desc; 515 ap.a_head.a_ops = ops; 516 ap.a_vp = vp; 517 ap.a_command = command; 518 ap.a_data = data; 519 ap.a_fflag = fflag; 520 ap.a_cred = cred; 521 ap.a_sysmsg = msg; 522 523 VFS_MPLOCK(vp->v_mount); 524 DO_OPS(ops, error, &ap, vop_ioctl); 525 VFS_MPUNLOCK(); 526 527 return(error); 528 } 529 530 /* 531 * MPSAFE 532 */ 533 int 534 vop_poll(struct vop_ops *ops, struct vnode *vp, int events, struct ucred *cred) 535 { 536 struct vop_poll_args ap; 537 VFS_MPLOCK_DECLARE; 538 int error; 539 540 ap.a_head.a_desc = &vop_poll_desc; 541 ap.a_head.a_ops = ops; 542 ap.a_vp = vp; 543 ap.a_events = events; 544 ap.a_cred = cred; 545 546 VFS_MPLOCK(vp->v_mount); 547 DO_OPS(ops, error, &ap, vop_poll); 548 VFS_MPUNLOCK(); 549 550 return(error); 551 } 552 553 /* 554 * MPSAFE 555 */ 556 int 557 vop_kqfilter(struct vop_ops *ops, struct vnode *vp, struct knote *kn) 558 { 559 struct vop_kqfilter_args ap; 560 VFS_MPLOCK_DECLARE; 561 int error; 562 563 ap.a_head.a_desc = &vop_kqfilter_desc; 564 ap.a_head.a_ops = ops; 565 ap.a_vp = vp; 566 ap.a_kn = kn; 567 568 VFS_MPLOCK(vp->v_mount); 569 DO_OPS(ops, error, &ap, vop_kqfilter); 570 VFS_MPUNLOCK(); 571 572 return(error); 573 } 574 575 /* 576 * MPSAFE 577 */ 578 int 579 vop_mmap(struct vop_ops *ops, struct vnode *vp, int fflags, struct ucred *cred) 580 { 581 struct vop_mmap_args ap; 582 VFS_MPLOCK_DECLARE; 583 int error; 584 585 ap.a_head.a_desc = &vop_mmap_desc; 586 ap.a_head.a_ops = ops; 587 ap.a_vp = vp; 588 ap.a_fflags = fflags; 589 ap.a_cred = cred; 590 591 VFS_MPLOCK(vp->v_mount); 592 DO_OPS(ops, error, &ap, vop_mmap); 593 VFS_MPUNLOCK(); 594 595 return(error); 596 } 597 598 /* 599 * MPSAFE 600 */ 601 int 602 vop_fsync(struct vop_ops *ops, struct vnode *vp, int waitfor, int flags, 603 struct file *fp) 604 { 605 struct vop_fsync_args ap; 606 VFS_MPLOCK_DECLARE; 607 int error; 608 609 ap.a_head.a_desc = &vop_fsync_desc; 610 ap.a_head.a_ops = ops; 611 ap.a_vp = vp; 612 ap.a_waitfor = waitfor; 613 ap.a_flags = flags; 614 ap.a_fp = fp; 615 616 VFS_MPLOCK(vp->v_mount); 617 DO_OPS(ops, error, &ap, vop_fsync); 618 VFS_MPUNLOCK(); 619 620 return(error); 621 } 622 623 /* 624 * MPSAFE 625 */ 626 int 627 vop_old_remove(struct vop_ops *ops, struct vnode *dvp, 628 struct vnode *vp, struct componentname *cnp) 629 { 630 struct vop_old_remove_args ap; 631 VFS_MPLOCK_DECLARE; 632 int error; 633 634 ap.a_head.a_desc = &vop_old_remove_desc; 635 ap.a_head.a_ops = ops; 636 ap.a_dvp = dvp; 637 ap.a_vp = vp; 638 ap.a_cnp = cnp; 639 640 VFS_MPLOCK(dvp->v_mount); 641 DO_OPS(ops, error, &ap, vop_old_remove); 642 VFS_MPUNLOCK(); 643 644 return(error); 645 } 646 647 /* 648 * MPSAFE 649 */ 650 int 651 vop_old_link(struct vop_ops *ops, struct vnode *tdvp, 652 struct vnode *vp, struct componentname *cnp) 653 { 654 struct vop_old_link_args ap; 655 VFS_MPLOCK_DECLARE; 656 int error; 657 658 ap.a_head.a_desc = &vop_old_link_desc; 659 ap.a_head.a_ops = ops; 660 ap.a_tdvp = tdvp; 661 ap.a_vp = vp; 662 ap.a_cnp = cnp; 663 664 VFS_MPLOCK(tdvp->v_mount); 665 DO_OPS(ops, error, &ap, vop_old_link); 666 VFS_MPUNLOCK(); 667 668 return(error); 669 } 670 671 /* 672 * MPSAFE 673 */ 674 int 675 vop_old_rename(struct vop_ops *ops, 676 struct vnode *fdvp, struct vnode *fvp, struct componentname *fcnp, 677 struct vnode *tdvp, struct vnode *tvp, struct componentname *tcnp) 678 { 679 struct vop_old_rename_args ap; 680 VFS_MPLOCK_DECLARE; 681 int error; 682 683 ap.a_head.a_desc = &vop_old_rename_desc; 684 ap.a_head.a_ops = ops; 685 ap.a_fdvp = fdvp; 686 ap.a_fvp = fvp; 687 ap.a_fcnp = fcnp; 688 ap.a_tdvp = tdvp; 689 ap.a_tvp = tvp; 690 ap.a_tcnp = tcnp; 691 692 VFS_MPLOCK(tdvp->v_mount); 693 DO_OPS(ops, error, &ap, vop_old_rename); 694 VFS_MPUNLOCK(); 695 696 return(error); 697 } 698 699 /* 700 * MPSAFE 701 */ 702 int 703 vop_old_mkdir(struct vop_ops *ops, struct vnode *dvp, 704 struct vnode **vpp, struct componentname *cnp, struct vattr *vap) 705 { 706 struct vop_old_mkdir_args ap; 707 VFS_MPLOCK_DECLARE; 708 int error; 709 710 ap.a_head.a_desc = &vop_old_mkdir_desc; 711 ap.a_head.a_ops = ops; 712 ap.a_dvp = dvp; 713 ap.a_vpp = vpp; 714 ap.a_cnp = cnp; 715 ap.a_vap = vap; 716 717 VFS_MPLOCK(dvp->v_mount); 718 DO_OPS(ops, error, &ap, vop_old_mkdir); 719 VFS_MPUNLOCK(); 720 721 return(error); 722 } 723 724 /* 725 * MPSAFE 726 */ 727 int 728 vop_old_rmdir(struct vop_ops *ops, struct vnode *dvp, 729 struct vnode *vp, struct componentname *cnp) 730 { 731 struct vop_old_rmdir_args ap; 732 VFS_MPLOCK_DECLARE; 733 int error; 734 735 ap.a_head.a_desc = &vop_old_rmdir_desc; 736 ap.a_head.a_ops = ops; 737 ap.a_dvp = dvp; 738 ap.a_vp = vp; 739 ap.a_cnp = cnp; 740 741 VFS_MPLOCK(dvp->v_mount); 742 DO_OPS(ops, error, &ap, vop_old_rmdir); 743 VFS_MPUNLOCK(); 744 745 return(error); 746 } 747 748 /* 749 * MPSAFE 750 */ 751 int 752 vop_old_symlink(struct vop_ops *ops, struct vnode *dvp, 753 struct vnode **vpp, struct componentname *cnp, 754 struct vattr *vap, char *target) 755 { 756 struct vop_old_symlink_args ap; 757 VFS_MPLOCK_DECLARE; 758 int error; 759 760 ap.a_head.a_desc = &vop_old_symlink_desc; 761 ap.a_head.a_ops = ops; 762 ap.a_dvp = dvp; 763 ap.a_vpp = vpp; 764 ap.a_cnp = cnp; 765 ap.a_vap = vap; 766 ap.a_target = target; 767 768 VFS_MPLOCK(dvp->v_mount); 769 DO_OPS(ops, error, &ap, vop_old_symlink); 770 VFS_MPUNLOCK(); 771 772 return(error); 773 } 774 775 /* 776 * MPSAFE 777 */ 778 int 779 vop_readdir(struct vop_ops *ops, struct vnode *vp, struct uio *uio, 780 struct ucred *cred, int *eofflag, int *ncookies, off_t **cookies, 781 struct file *fp) 782 { 783 struct vop_readdir_args ap; 784 VFS_MPLOCK_DECLARE; 785 int error; 786 787 ap.a_head.a_desc = &vop_readdir_desc; 788 ap.a_head.a_ops = ops; 789 ap.a_vp = vp; 790 ap.a_uio = uio; 791 ap.a_cred = cred; 792 ap.a_eofflag = eofflag; 793 ap.a_ncookies = ncookies; 794 ap.a_cookies = cookies; 795 ap.a_fp = fp; 796 797 VFS_MPLOCK(vp->v_mount); 798 DO_OPS(ops, error, &ap, vop_readdir); 799 VFS_MPUNLOCK(); 800 801 return(error); 802 } 803 804 /* 805 * MPSAFE 806 */ 807 int 808 vop_readlink(struct vop_ops *ops, struct vnode *vp, struct uio *uio, 809 struct ucred *cred) 810 { 811 struct vop_readlink_args ap; 812 VFS_MPLOCK_DECLARE; 813 int error; 814 815 ap.a_head.a_desc = &vop_readlink_desc; 816 ap.a_head.a_ops = ops; 817 ap.a_vp = vp; 818 ap.a_uio = uio; 819 ap.a_cred = cred; 820 821 VFS_MPLOCK(vp->v_mount); 822 DO_OPS(ops, error, &ap, vop_readlink); 823 VFS_MPUNLOCK(); 824 825 return(error); 826 } 827 828 /* 829 * MPSAFE 830 */ 831 int 832 vop_inactive(struct vop_ops *ops, struct vnode *vp) 833 { 834 struct vop_inactive_args ap; 835 struct mount *mp; 836 VFS_MPLOCK_DECLARE; 837 int error; 838 839 ap.a_head.a_desc = &vop_inactive_desc; 840 ap.a_head.a_ops = ops; 841 ap.a_vp = vp; 842 843 /* 844 * WARNING! Deactivation of the vnode can cause it to be recycled, 845 * clearing vp->v_mount. 846 */ 847 mp = vp->v_mount; 848 VFS_MPLOCK_FLAG(mp, MNTK_IN_MPSAFE); 849 DO_OPS(ops, error, &ap, vop_inactive); 850 VFS_MPUNLOCK(); 851 852 return(error); 853 } 854 855 /* 856 * MPSAFE 857 */ 858 int 859 vop_reclaim(struct vop_ops *ops, struct vnode *vp) 860 { 861 struct vop_reclaim_args ap; 862 struct mount *mp; 863 VFS_MPLOCK_DECLARE; 864 int error; 865 866 ap.a_head.a_desc = &vop_reclaim_desc; 867 ap.a_head.a_ops = ops; 868 ap.a_vp = vp; 869 870 /* 871 * WARNING! Reclamation of the vnode will clear vp->v_mount. 872 */ 873 mp = vp->v_mount; 874 VFS_MPLOCK(mp); 875 DO_OPS(ops, error, &ap, vop_reclaim); 876 VFS_MPUNLOCK(); 877 878 return(error); 879 } 880 881 /* 882 * MPSAFE 883 */ 884 int 885 vop_bmap(struct vop_ops *ops, struct vnode *vp, off_t loffset, 886 off_t *doffsetp, int *runp, int *runb, buf_cmd_t cmd) 887 { 888 struct vop_bmap_args ap; 889 VFS_MPLOCK_DECLARE; 890 int error; 891 892 ap.a_head.a_desc = &vop_bmap_desc; 893 ap.a_head.a_ops = ops; 894 ap.a_vp = vp; 895 ap.a_loffset = loffset; 896 ap.a_doffsetp = doffsetp; 897 ap.a_runp = runp; 898 ap.a_runb = runb; 899 ap.a_cmd = cmd; 900 901 VFS_MPLOCK(vp->v_mount); 902 DO_OPS(ops, error, &ap, vop_bmap); 903 VFS_MPUNLOCK(); 904 905 return(error); 906 } 907 908 /* 909 * WARNING! Vnode can go-away after the ops call (e.g. async flush 910 * from buffer kthread). 911 */ 912 int 913 vop_strategy(struct vop_ops *ops, struct vnode *vp, struct bio *bio) 914 { 915 struct vop_strategy_args ap; 916 VFS_MPLOCK_DECLARE; 917 int error; 918 919 ap.a_head.a_desc = &vop_strategy_desc; 920 ap.a_head.a_ops = ops; 921 ap.a_vp = vp; 922 ap.a_bio = bio; 923 924 if (vp->v_mount) { 925 VFS_MPLOCK_FLAG(vp->v_mount, MNTK_SG_MPSAFE); 926 DO_OPS(ops, error, &ap, vop_strategy); 927 VFS_MPUNLOCK(); 928 } else { 929 /* ugly hack for swap */ 930 get_mplock(); 931 DO_OPS(ops, error, &ap, vop_strategy); 932 rel_mplock(); 933 } 934 return(error); 935 } 936 937 /* 938 * MPSAFE 939 */ 940 int 941 vop_print(struct vop_ops *ops, struct vnode *vp) 942 { 943 struct vop_print_args ap; 944 VFS_MPLOCK_DECLARE; 945 int error; 946 947 ap.a_head.a_desc = &vop_print_desc; 948 ap.a_head.a_ops = ops; 949 ap.a_vp = vp; 950 951 VFS_MPLOCK(vp->v_mount); 952 DO_OPS(ops, error, &ap, vop_print); 953 VFS_MPUNLOCK(); 954 955 return(error); 956 } 957 958 /* 959 * MPSAFE 960 */ 961 int 962 vop_pathconf(struct vop_ops *ops, struct vnode *vp, int name, 963 register_t *retval) 964 { 965 struct vop_pathconf_args ap; 966 VFS_MPLOCK_DECLARE; 967 int error; 968 969 ap.a_head.a_desc = &vop_pathconf_desc; 970 ap.a_head.a_ops = ops; 971 ap.a_vp = vp; 972 ap.a_name = name; 973 ap.a_retval = retval; 974 975 VFS_MPLOCK(vp->v_mount); 976 DO_OPS(ops, error, &ap, vop_pathconf); 977 VFS_MPUNLOCK(); 978 979 return(error); 980 } 981 982 /* 983 * MPSAFE 984 */ 985 int 986 vop_advlock(struct vop_ops *ops, struct vnode *vp, caddr_t id, int op, 987 struct flock *fl, int flags) 988 { 989 struct vop_advlock_args ap; 990 VFS_MPLOCK_DECLARE; 991 int error; 992 993 ap.a_head.a_desc = &vop_advlock_desc; 994 ap.a_head.a_ops = ops; 995 ap.a_vp = vp; 996 ap.a_id = id; 997 ap.a_op = op; 998 ap.a_fl = fl; 999 ap.a_flags = flags; 1000 1001 VFS_MPLOCK(vp->v_mount); 1002 DO_OPS(ops, error, &ap, vop_advlock); 1003 VFS_MPUNLOCK(); 1004 1005 return(error); 1006 } 1007 1008 /* 1009 * MPSAFE 1010 */ 1011 int 1012 vop_balloc(struct vop_ops *ops, struct vnode *vp, off_t startoffset, 1013 int size, struct ucred *cred, int flags, 1014 struct buf **bpp) 1015 { 1016 struct vop_balloc_args ap; 1017 VFS_MPLOCK_DECLARE; 1018 int error; 1019 1020 ap.a_head.a_desc = &vop_balloc_desc; 1021 ap.a_head.a_ops = ops; 1022 ap.a_vp = vp; 1023 ap.a_startoffset = startoffset; 1024 ap.a_size = size; 1025 ap.a_cred = cred; 1026 ap.a_flags = flags; 1027 ap.a_bpp = bpp; 1028 1029 VFS_MPLOCK(vp->v_mount); 1030 DO_OPS(ops, error, &ap, vop_balloc); 1031 VFS_MPUNLOCK(); 1032 1033 return(error); 1034 } 1035 1036 /* 1037 * MPSAFE 1038 */ 1039 int 1040 vop_reallocblks(struct vop_ops *ops, struct vnode *vp, 1041 struct cluster_save *buflist) 1042 { 1043 struct vop_reallocblks_args ap; 1044 VFS_MPLOCK_DECLARE; 1045 int error; 1046 1047 ap.a_head.a_desc = &vop_reallocblks_desc; 1048 ap.a_head.a_ops = ops; 1049 ap.a_vp = vp; 1050 ap.a_buflist = buflist; 1051 1052 VFS_MPLOCK(vp->v_mount); 1053 DO_OPS(ops, error, &ap, vop_reallocblks); 1054 VFS_MPUNLOCK(); 1055 1056 return(error); 1057 } 1058 1059 /* 1060 * MPSAFE 1061 */ 1062 int 1063 vop_getpages(struct vop_ops *ops, struct vnode *vp, vm_page_t *m, int count, 1064 int reqpage, vm_ooffset_t offset, int seqaccess) 1065 { 1066 struct vop_getpages_args ap; 1067 VFS_MPLOCK_DECLARE; 1068 int error; 1069 1070 ap.a_head.a_desc = &vop_getpages_desc; 1071 ap.a_head.a_ops = ops; 1072 ap.a_vp = vp; 1073 ap.a_m = m; 1074 ap.a_count = count; 1075 ap.a_reqpage = reqpage; 1076 ap.a_offset = offset; 1077 ap.a_seqaccess = seqaccess; 1078 1079 VFS_MPLOCK(vp->v_mount); 1080 DO_OPS(ops, error, &ap, vop_getpages); 1081 VFS_MPUNLOCK(); 1082 1083 return(error); 1084 } 1085 1086 /* 1087 * MPSAFE 1088 */ 1089 int 1090 vop_putpages(struct vop_ops *ops, struct vnode *vp, vm_page_t *m, int count, 1091 int flags, int *rtvals, vm_ooffset_t offset) 1092 { 1093 struct vop_putpages_args ap; 1094 VFS_MPLOCK_DECLARE; 1095 int error; 1096 1097 ap.a_head.a_desc = &vop_putpages_desc; 1098 ap.a_head.a_ops = ops; 1099 ap.a_vp = vp; 1100 ap.a_m = m; 1101 ap.a_count = count; 1102 ap.a_flags = flags; 1103 ap.a_rtvals = rtvals; 1104 ap.a_offset = offset; 1105 1106 VFS_MPLOCK(vp->v_mount); 1107 DO_OPS(ops, error, &ap, vop_putpages); 1108 VFS_MPUNLOCK(); 1109 1110 return(error); 1111 } 1112 1113 /* 1114 * MPSAFE 1115 */ 1116 int 1117 vop_freeblks(struct vop_ops *ops, struct vnode *vp, off_t offset, int length) 1118 { 1119 struct vop_freeblks_args ap; 1120 VFS_MPLOCK_DECLARE; 1121 int error; 1122 1123 ap.a_head.a_desc = &vop_freeblks_desc; 1124 ap.a_head.a_ops = ops; 1125 ap.a_vp = vp; 1126 ap.a_offset = offset; 1127 ap.a_length = length; 1128 1129 VFS_MPLOCK(vp->v_mount); 1130 DO_OPS(ops, error, &ap, vop_freeblks); 1131 VFS_MPUNLOCK(); 1132 1133 return(error); 1134 } 1135 1136 /* 1137 * MPSAFE 1138 */ 1139 int 1140 vop_getacl(struct vop_ops *ops, struct vnode *vp, acl_type_t type, 1141 struct acl *aclp, struct ucred *cred) 1142 { 1143 struct vop_getacl_args ap; 1144 VFS_MPLOCK_DECLARE; 1145 int error; 1146 1147 ap.a_head.a_desc = &vop_getacl_desc; 1148 ap.a_head.a_ops = ops; 1149 ap.a_vp = vp; 1150 ap.a_type = type; 1151 ap.a_aclp = aclp; 1152 ap.a_cred = cred; 1153 1154 VFS_MPLOCK(vp->v_mount); 1155 DO_OPS(ops, error, &ap, vop_getacl); 1156 VFS_MPUNLOCK(); 1157 1158 return(error); 1159 } 1160 1161 /* 1162 * MPSAFE 1163 */ 1164 int 1165 vop_setacl(struct vop_ops *ops, struct vnode *vp, acl_type_t type, 1166 struct acl *aclp, struct ucred *cred) 1167 { 1168 struct vop_setacl_args ap; 1169 VFS_MPLOCK_DECLARE; 1170 int error; 1171 1172 ap.a_head.a_desc = &vop_setacl_desc; 1173 ap.a_head.a_ops = ops; 1174 ap.a_vp = vp; 1175 ap.a_type = type; 1176 ap.a_aclp = aclp; 1177 ap.a_cred = cred; 1178 1179 VFS_MPLOCK(vp->v_mount); 1180 DO_OPS(ops, error, &ap, vop_setacl); 1181 VFS_MPUNLOCK(); 1182 1183 return(error); 1184 } 1185 1186 /* 1187 * MPSAFE 1188 */ 1189 int 1190 vop_aclcheck(struct vop_ops *ops, struct vnode *vp, acl_type_t type, 1191 struct acl *aclp, struct ucred *cred) 1192 { 1193 struct vop_aclcheck_args ap; 1194 VFS_MPLOCK_DECLARE; 1195 int error; 1196 1197 ap.a_head.a_desc = &vop_aclcheck_desc; 1198 ap.a_head.a_ops = ops; 1199 ap.a_vp = vp; 1200 ap.a_type = type; 1201 ap.a_aclp = aclp; 1202 ap.a_cred = cred; 1203 1204 VFS_MPLOCK(vp->v_mount); 1205 DO_OPS(ops, error, &ap, vop_aclcheck); 1206 VFS_MPUNLOCK(); 1207 1208 return(error); 1209 } 1210 1211 /* 1212 * MPSAFE 1213 */ 1214 int 1215 vop_getextattr(struct vop_ops *ops, struct vnode *vp, int attrnamespace, 1216 char *attrname, struct uio *uio, struct ucred *cred) 1217 { 1218 struct vop_getextattr_args ap; 1219 VFS_MPLOCK_DECLARE; 1220 int error; 1221 1222 ap.a_head.a_desc = &vop_getextattr_desc; 1223 ap.a_head.a_ops = ops; 1224 ap.a_vp = vp; 1225 ap.a_attrnamespace = attrnamespace; 1226 ap.a_attrname = attrname; 1227 ap.a_uio = uio; 1228 ap.a_cred = cred; 1229 1230 VFS_MPLOCK(vp->v_mount); 1231 DO_OPS(ops, error, &ap, vop_getextattr); 1232 VFS_MPUNLOCK(); 1233 1234 return(error); 1235 } 1236 1237 /* 1238 * MPSAFE 1239 */ 1240 int 1241 vop_setextattr(struct vop_ops *ops, struct vnode *vp, int attrnamespace, 1242 char *attrname, struct uio *uio, struct ucred *cred) 1243 { 1244 struct vop_setextattr_args ap; 1245 VFS_MPLOCK_DECLARE; 1246 int error; 1247 1248 ap.a_head.a_desc = &vop_setextattr_desc; 1249 ap.a_head.a_ops = ops; 1250 ap.a_vp = vp; 1251 ap.a_attrnamespace = attrnamespace; 1252 ap.a_attrname = attrname; 1253 ap.a_uio = uio; 1254 ap.a_cred = cred; 1255 1256 VFS_MPLOCK(vp->v_mount); 1257 DO_OPS(ops, error, &ap, vop_setextattr); 1258 VFS_MPUNLOCK(); 1259 1260 return(error); 1261 } 1262 1263 /* 1264 * MPSAFE 1265 */ 1266 int 1267 vop_mountctl(struct vop_ops *ops, struct vnode *vp, int op, struct file *fp, 1268 const void *ctl, int ctllen, void *buf, int buflen, int *res) 1269 { 1270 struct vop_mountctl_args ap; 1271 VFS_MPLOCK_DECLARE; 1272 int error; 1273 1274 ap.a_head.a_desc = &vop_mountctl_desc; 1275 ap.a_head.a_ops = ops; 1276 ap.a_op = op; 1277 ap.a_ctl = ctl; 1278 ap.a_fp = fp; 1279 ap.a_ctllen = ctllen; 1280 ap.a_buf = buf; 1281 ap.a_buflen = buflen; 1282 ap.a_res = res; 1283 1284 VFS_MPLOCK(vp->v_mount); 1285 DO_OPS(ops, error, &ap, vop_mountctl); 1286 VFS_MPUNLOCK(); 1287 1288 return(error); 1289 } 1290 1291 /* 1292 * MPSAFE 1293 */ 1294 int 1295 vop_markatime(struct vop_ops *ops, struct vnode *vp, struct ucred *cred) 1296 { 1297 struct vop_markatime_args ap; 1298 VFS_MPLOCK_DECLARE; 1299 int error; 1300 1301 ap.a_head.a_desc = &vop_markatime_desc; 1302 ap.a_head.a_ops = ops; 1303 ap.a_vp = vp; 1304 ap.a_cred = cred; 1305 1306 VFS_MPLOCK(vp->v_mount); 1307 DO_OPS(ops, error, &ap, vop_markatime); 1308 VFS_MPUNLOCK(); 1309 1310 return(error); 1311 } 1312 1313 /* 1314 * NEW API FUNCTIONS 1315 * 1316 * nresolve takes a locked ncp, a referenced but unlocked dvp, and a cred, 1317 * and resolves the ncp into a positive or negative hit. 1318 * 1319 * The namecache is automatically adjusted by this function. The ncp 1320 * is left locked on return. 1321 * 1322 * MPSAFE 1323 */ 1324 int 1325 vop_nresolve(struct vop_ops *ops, struct nchandle *nch, 1326 struct vnode *dvp, struct ucred *cred) 1327 { 1328 struct vop_nresolve_args ap; 1329 VFS_MPLOCK_DECLARE; 1330 int error; 1331 1332 ap.a_head.a_desc = &vop_nresolve_desc; 1333 ap.a_head.a_ops = ops; 1334 ap.a_nch = nch; 1335 ap.a_dvp = dvp; 1336 ap.a_cred = cred; 1337 1338 VFS_MPLOCK(dvp->v_mount); 1339 DO_OPS(ops, error, &ap, vop_nresolve); 1340 VFS_MPUNLOCK(); 1341 1342 return(error); 1343 } 1344 1345 /* 1346 * nlookupdotdot takes an unlocked directory, referenced dvp, and looks 1347 * up "..", returning a locked parent directory in *vpp. If an error 1348 * occurs *vpp will be NULL. 1349 * 1350 * MPSAFE 1351 */ 1352 int 1353 vop_nlookupdotdot(struct vop_ops *ops, struct vnode *dvp, 1354 struct vnode **vpp, struct ucred *cred, char **fakename) 1355 { 1356 struct vop_nlookupdotdot_args ap; 1357 VFS_MPLOCK_DECLARE; 1358 int error; 1359 1360 ap.a_head.a_desc = &vop_nlookupdotdot_desc; 1361 ap.a_head.a_ops = ops; 1362 ap.a_dvp = dvp; 1363 ap.a_vpp = vpp; 1364 ap.a_cred = cred; 1365 ap.a_fakename = fakename; 1366 1367 VFS_MPLOCK(dvp->v_mount); 1368 DO_OPS(ops, error, &ap, vop_nlookupdotdot); 1369 VFS_MPUNLOCK(); 1370 1371 return(error); 1372 } 1373 1374 /* 1375 * ncreate takes a locked, resolved ncp that typically represents a negative 1376 * cache hit and creates the file or node specified by the ncp, cred, and 1377 * vattr. If no error occurs a locked vnode is returned in *vpp. 1378 * 1379 * The dvp passed in is referenced but unlocked. 1380 * 1381 * The namecache is automatically adjusted by this function. The ncp 1382 * is left locked on return. 1383 * 1384 * MPSAFE 1385 */ 1386 int 1387 vop_ncreate(struct vop_ops *ops, struct nchandle *nch, struct vnode *dvp, 1388 struct vnode **vpp, struct ucred *cred, struct vattr *vap) 1389 { 1390 struct vop_ncreate_args ap; 1391 VFS_MPLOCK_DECLARE; 1392 int error; 1393 1394 ap.a_head.a_desc = &vop_ncreate_desc; 1395 ap.a_head.a_ops = ops; 1396 ap.a_nch = nch; 1397 ap.a_dvp = dvp; 1398 ap.a_vpp = vpp; 1399 ap.a_cred = cred; 1400 ap.a_vap = vap; 1401 1402 VFS_MPLOCK(dvp->v_mount); 1403 DO_OPS(ops, error, &ap, vop_ncreate); 1404 VFS_MPUNLOCK(); 1405 1406 return(error); 1407 } 1408 1409 /* 1410 * nmkdir takes a locked, resolved ncp that typically represents a negative 1411 * cache hit and creates the directory specified by the ncp, cred, and 1412 * vattr. If no error occurs a locked vnode is returned in *vpp. 1413 * 1414 * The dvp passed in is referenced but unlocked. 1415 * 1416 * The namecache is automatically adjusted by this function. The ncp 1417 * is left locked on return. 1418 * 1419 * MPSAFE 1420 */ 1421 int 1422 vop_nmkdir(struct vop_ops *ops, struct nchandle *nch, struct vnode *dvp, 1423 struct vnode **vpp, struct ucred *cred, struct vattr *vap) 1424 { 1425 struct vop_nmkdir_args ap; 1426 VFS_MPLOCK_DECLARE; 1427 int error; 1428 1429 ap.a_head.a_desc = &vop_nmkdir_desc; 1430 ap.a_head.a_ops = ops; 1431 ap.a_nch = nch; 1432 ap.a_dvp = dvp; 1433 ap.a_vpp = vpp; 1434 ap.a_cred = cred; 1435 ap.a_vap = vap; 1436 1437 VFS_MPLOCK(dvp->v_mount); 1438 DO_OPS(ops, error, &ap, vop_nmkdir); 1439 VFS_MPUNLOCK(); 1440 1441 return(error); 1442 } 1443 1444 /* 1445 * nmknod takes a locked, resolved ncp that typically represents a negative 1446 * cache hit and creates the node specified by the ncp, cred, and 1447 * vattr. If no error occurs a locked vnode is returned in *vpp. 1448 * 1449 * The dvp passed in is referenced but unlocked. 1450 * 1451 * The namecache is automatically adjusted by this function. The ncp 1452 * is left locked on return. 1453 * 1454 * MPSAFE 1455 */ 1456 int 1457 vop_nmknod(struct vop_ops *ops, struct nchandle *nch, struct vnode *dvp, 1458 struct vnode **vpp, struct ucred *cred, struct vattr *vap) 1459 { 1460 struct vop_nmknod_args ap; 1461 VFS_MPLOCK_DECLARE; 1462 int error; 1463 1464 ap.a_head.a_desc = &vop_nmknod_desc; 1465 ap.a_head.a_ops = ops; 1466 ap.a_nch = nch; 1467 ap.a_dvp = dvp; 1468 ap.a_vpp = vpp; 1469 ap.a_cred = cred; 1470 ap.a_vap = vap; 1471 1472 VFS_MPLOCK(dvp->v_mount); 1473 DO_OPS(ops, error, &ap, vop_nmknod); 1474 VFS_MPUNLOCK(); 1475 1476 return(error); 1477 } 1478 1479 /* 1480 * nlink takes a locked, resolved ncp that typically represents a negative 1481 * cache hit and creates the node specified by the ncp, cred, and 1482 * existing vnode. The passed vp must be locked and will remain locked 1483 * on return, as does the ncp, whether an error occurs or not. 1484 * 1485 * The dvp passed in is referenced but unlocked. 1486 * 1487 * The namecache is automatically adjusted by this function. The ncp 1488 * is left locked on return. 1489 * 1490 * MPSAFE 1491 */ 1492 int 1493 vop_nlink(struct vop_ops *ops, struct nchandle *nch, struct vnode *dvp, 1494 struct vnode *vp, struct ucred *cred) 1495 { 1496 struct vop_nlink_args ap; 1497 VFS_MPLOCK_DECLARE; 1498 int error; 1499 1500 ap.a_head.a_desc = &vop_nlink_desc; 1501 ap.a_head.a_ops = ops; 1502 ap.a_nch = nch; 1503 ap.a_dvp = dvp; 1504 ap.a_vp = vp; 1505 ap.a_cred = cred; 1506 1507 VFS_MPLOCK(dvp->v_mount); 1508 DO_OPS(ops, error, &ap, vop_nlink); 1509 VFS_MPUNLOCK(); 1510 1511 return(error); 1512 } 1513 1514 /* 1515 * nsymlink takes a locked, resolved ncp that typically represents a negative 1516 * cache hit and creates a symbolic link based on cred, vap, and target (the 1517 * contents of the link). If no error occurs a locked vnode is returned in 1518 * *vpp. 1519 * 1520 * The dvp passed in is referenced but unlocked. 1521 * 1522 * The namecache is automatically adjusted by this function. The ncp 1523 * is left locked on return. 1524 * 1525 * MPSAFE 1526 */ 1527 int 1528 vop_nsymlink(struct vop_ops *ops, struct nchandle *nch, struct vnode *dvp, 1529 struct vnode **vpp, struct ucred *cred, 1530 struct vattr *vap, char *target) 1531 { 1532 struct vop_nsymlink_args ap; 1533 VFS_MPLOCK_DECLARE; 1534 int error; 1535 1536 ap.a_head.a_desc = &vop_nsymlink_desc; 1537 ap.a_head.a_ops = ops; 1538 ap.a_nch = nch; 1539 ap.a_dvp = dvp; 1540 ap.a_vpp = vpp; 1541 ap.a_cred = cred; 1542 ap.a_vap = vap; 1543 ap.a_target = target; 1544 1545 VFS_MPLOCK(dvp->v_mount); 1546 DO_OPS(ops, error, &ap, vop_nsymlink); 1547 VFS_MPUNLOCK(); 1548 1549 return(error); 1550 } 1551 1552 /* 1553 * nwhiteout takes a locked, resolved ncp that can represent a positive or 1554 * negative hit and executes the whiteout function specified in flags. 1555 * 1556 * The dvp passed in is referenced but unlocked. 1557 * 1558 * The namecache is automatically adjusted by this function. The ncp 1559 * is left locked on return. 1560 * 1561 * MPSAFE 1562 */ 1563 int 1564 vop_nwhiteout(struct vop_ops *ops, struct nchandle *nch, struct vnode *dvp, 1565 struct ucred *cred, int flags) 1566 { 1567 struct vop_nwhiteout_args ap; 1568 VFS_MPLOCK_DECLARE; 1569 int error; 1570 1571 ap.a_head.a_desc = &vop_nwhiteout_desc; 1572 ap.a_head.a_ops = ops; 1573 ap.a_nch = nch; 1574 ap.a_dvp = dvp; 1575 ap.a_cred = cred; 1576 ap.a_flags = flags; 1577 1578 VFS_MPLOCK(dvp->v_mount); 1579 DO_OPS(ops, error, &ap, vop_nwhiteout); 1580 VFS_MPUNLOCK(); 1581 1582 return(error); 1583 } 1584 1585 /* 1586 * nremove takes a locked, resolved ncp that generally represents a 1587 * positive hit and removes the file. 1588 * 1589 * The dvp passed in is referenced but unlocked. 1590 * 1591 * The namecache is automatically adjusted by this function. The ncp 1592 * is left locked on return. 1593 * 1594 * MPSAFE 1595 */ 1596 int 1597 vop_nremove(struct vop_ops *ops, struct nchandle *nch, struct vnode *dvp, 1598 struct ucred *cred) 1599 { 1600 struct vop_nremove_args ap; 1601 VFS_MPLOCK_DECLARE; 1602 int error; 1603 struct vattr va; 1604 1605 ap.a_head.a_desc = &vop_nremove_desc; 1606 ap.a_head.a_ops = ops; 1607 ap.a_nch = nch; 1608 ap.a_dvp = dvp; 1609 ap.a_cred = cred; 1610 1611 if ((error = VOP_GETATTR(nch->ncp->nc_vp, &va)) != 0) 1612 return (error); 1613 1614 VFS_MPLOCK(dvp->v_mount); 1615 DO_OPS(ops, error, &ap, vop_nremove); 1616 /* Only update space counters if this is the last hard link */ 1617 if ((error == 0) && (va.va_nlink == 1)) { 1618 VFS_ACCOUNT(nch->mount, va.va_uid, va.va_gid, -va.va_size); 1619 } 1620 VFS_MPUNLOCK(); 1621 1622 return(error); 1623 } 1624 1625 /* 1626 * nrmdir takes a locked, resolved ncp that generally represents a 1627 * directory and removes the directory. 1628 * 1629 * The dvp passed in is referenced but unlocked. 1630 * 1631 * The namecache is automatically adjusted by this function. The ncp 1632 * is left locked on return. 1633 * 1634 * MPSAFE 1635 */ 1636 int 1637 vop_nrmdir(struct vop_ops *ops, struct nchandle *nch, struct vnode *dvp, 1638 struct ucred *cred) 1639 { 1640 struct vop_nrmdir_args ap; 1641 VFS_MPLOCK_DECLARE; 1642 int error; 1643 1644 ap.a_head.a_desc = &vop_nrmdir_desc; 1645 ap.a_head.a_ops = ops; 1646 ap.a_nch = nch; 1647 ap.a_dvp = dvp; 1648 ap.a_cred = cred; 1649 1650 VFS_MPLOCK(dvp->v_mount); 1651 DO_OPS(ops, error, &ap, vop_nrmdir); 1652 VFS_MPUNLOCK(); 1653 1654 return(error); 1655 } 1656 1657 /* 1658 * nrename takes TWO locked, resolved ncp's and the cred of the caller 1659 * and renames the source ncp to the target ncp. The target ncp may 1660 * represent a positive or negative hit. 1661 * 1662 * The fdvp and tdvp passed in are referenced but unlocked. 1663 * 1664 * The namecache is automatically adjusted by this function. The ncp 1665 * is left locked on return. The source ncp is typically changed to 1666 * a negative cache hit and the target ncp typically takes on the 1667 * source ncp's underlying file. 1668 * 1669 * MPSAFE 1670 */ 1671 int 1672 vop_nrename(struct vop_ops *ops, 1673 struct nchandle *fnch, struct nchandle *tnch, 1674 struct vnode *fdvp, struct vnode *tdvp, 1675 struct ucred *cred) 1676 { 1677 struct vop_nrename_args ap; 1678 VFS_MPLOCK_DECLARE; 1679 int error; 1680 1681 ap.a_head.a_desc = &vop_nrename_desc; 1682 ap.a_head.a_ops = ops; 1683 ap.a_fnch = fnch; 1684 ap.a_tnch = tnch; 1685 ap.a_fdvp = fdvp; 1686 ap.a_tdvp = tdvp; 1687 ap.a_cred = cred; 1688 1689 VFS_MPLOCK(fdvp->v_mount); 1690 DO_OPS(ops, error, &ap, vop_nrename); 1691 VFS_MPUNLOCK(); 1692 1693 return(error); 1694 } 1695 1696 /************************************************************************ 1697 * PRIMARY VNODE OPERATIONS FORWARDING CALLS * 1698 ************************************************************************ 1699 * 1700 * These procedures are called from VFSs such as nullfs 1701 * when they wish to forward an operation on one VFS to another. The 1702 * argument structure/message is modified and then directly passed to the 1703 * appropriate routine. This routines may also be called by initiators 1704 * who have an argument structure in hand rather then discreet arguments. 1705 * 1706 * MPSAFE - Caller expected to already hold the appropriate vfs lock. 1707 */ 1708 int 1709 vop_vnoperate_ap(struct vop_generic_args *ap) 1710 { 1711 struct vop_ops *ops; 1712 int error; 1713 1714 ops = ap->a_ops; 1715 error = VOCALL(ops, ap); 1716 1717 return (error); 1718 } 1719 1720 /* 1721 * This routine is called by the cache coherency layer to execute the actual 1722 * VFS operation. If a journaling layer is present we call though it, else 1723 * we call the native VOP functions. 1724 */ 1725 int 1726 vop_cache_operate_ap(struct vop_generic_args *ap) 1727 { 1728 struct vop_ops *ops; 1729 int error; 1730 1731 ops = ap->a_ops; 1732 if (ops->head.vv_mount->mnt_vn_journal_ops) 1733 error = VOCALL(ops->head.vv_mount->mnt_vn_journal_ops, ap); 1734 else 1735 error = VOCALL(ops->head.vv_mount->mnt_vn_norm_ops, ap); 1736 return (error); 1737 } 1738 1739 1740 /* 1741 * This routine is called by the journaling layer to execute the actual 1742 * VFS operation. 1743 */ 1744 int 1745 vop_journal_operate_ap(struct vop_generic_args *ap) 1746 { 1747 struct vop_ops *ops; 1748 int error; 1749 1750 ops = ap->a_ops; 1751 error = VOCALL(ops->head.vv_mount->mnt_vn_norm_ops, ap); 1752 1753 return (error); 1754 } 1755 1756 int 1757 vop_open_ap(struct vop_open_args *ap) 1758 { 1759 int error; 1760 1761 DO_OPS(ap->a_head.a_ops, error, ap, vop_open); 1762 return(error); 1763 } 1764 1765 int 1766 vop_close_ap(struct vop_close_args *ap) 1767 { 1768 int error; 1769 1770 DO_OPS(ap->a_head.a_ops, error, ap, vop_close); 1771 return(error); 1772 } 1773 1774 int 1775 vop_access_ap(struct vop_access_args *ap) 1776 { 1777 int error; 1778 1779 DO_OPS(ap->a_head.a_ops, error, ap, vop_access); 1780 return(error); 1781 } 1782 1783 int 1784 vop_getattr_ap(struct vop_getattr_args *ap) 1785 { 1786 int error; 1787 1788 DO_OPS(ap->a_head.a_ops, error, ap, vop_getattr); 1789 return(error); 1790 } 1791 1792 int 1793 vop_getattr_lite_ap(struct vop_getattr_lite_args *ap) 1794 { 1795 int error; 1796 1797 DO_OPS(ap->a_head.a_ops, error, ap, vop_getattr_lite); 1798 return(error); 1799 } 1800 1801 int 1802 vop_setattr_ap(struct vop_setattr_args *ap) 1803 { 1804 int error; 1805 1806 DO_OPS(ap->a_head.a_ops, error, ap, vop_setattr); 1807 return(error); 1808 } 1809 1810 int 1811 vop_read_ap(struct vop_read_args *ap) 1812 { 1813 int error; 1814 1815 DO_OPS(ap->a_head.a_ops, error, ap, vop_read); 1816 return(error); 1817 } 1818 1819 int 1820 vop_write_ap(struct vop_write_args *ap) 1821 { 1822 int error; 1823 1824 DO_OPS(ap->a_head.a_ops, error, ap, vop_write); 1825 return(error); 1826 } 1827 1828 int 1829 vop_ioctl_ap(struct vop_ioctl_args *ap) 1830 { 1831 int error; 1832 1833 DO_OPS(ap->a_head.a_ops, error, ap, vop_ioctl); 1834 return(error); 1835 } 1836 1837 int 1838 vop_poll_ap(struct vop_poll_args *ap) 1839 { 1840 int error; 1841 1842 DO_OPS(ap->a_head.a_ops, error, ap, vop_poll); 1843 return(error); 1844 } 1845 1846 int 1847 vop_kqfilter_ap(struct vop_kqfilter_args *ap) 1848 { 1849 int error; 1850 1851 DO_OPS(ap->a_head.a_ops, error, ap, vop_kqfilter); 1852 return(error); 1853 } 1854 1855 int 1856 vop_mmap_ap(struct vop_mmap_args *ap) 1857 { 1858 int error; 1859 1860 DO_OPS(ap->a_head.a_ops, error, ap, vop_mmap); 1861 return(error); 1862 } 1863 1864 int 1865 vop_fsync_ap(struct vop_fsync_args *ap) 1866 { 1867 int error; 1868 1869 DO_OPS(ap->a_head.a_ops, error, ap, vop_fsync); 1870 return(error); 1871 } 1872 1873 int 1874 vop_readdir_ap(struct vop_readdir_args *ap) 1875 { 1876 int error; 1877 1878 DO_OPS(ap->a_head.a_ops, error, ap, vop_readdir); 1879 return(error); 1880 } 1881 1882 int 1883 vop_readlink_ap(struct vop_readlink_args *ap) 1884 { 1885 int error; 1886 1887 DO_OPS(ap->a_head.a_ops, error, ap, vop_readlink); 1888 return(error); 1889 } 1890 1891 int 1892 vop_inactive_ap(struct vop_inactive_args *ap) 1893 { 1894 int error; 1895 1896 DO_OPS(ap->a_head.a_ops, error, ap, vop_inactive); 1897 return(error); 1898 } 1899 1900 int 1901 vop_reclaim_ap(struct vop_reclaim_args *ap) 1902 { 1903 int error; 1904 1905 DO_OPS(ap->a_head.a_ops, error, ap, vop_reclaim); 1906 return(error); 1907 } 1908 1909 int 1910 vop_bmap_ap(struct vop_bmap_args *ap) 1911 { 1912 int error; 1913 1914 DO_OPS(ap->a_head.a_ops, error, ap, vop_bmap); 1915 return(error); 1916 } 1917 1918 int 1919 vop_strategy_ap(struct vop_strategy_args *ap) 1920 { 1921 int error; 1922 1923 DO_OPS(ap->a_head.a_ops, error, ap, vop_strategy); 1924 return(error); 1925 } 1926 1927 int 1928 vop_print_ap(struct vop_print_args *ap) 1929 { 1930 int error; 1931 1932 DO_OPS(ap->a_head.a_ops, error, ap, vop_print); 1933 return(error); 1934 } 1935 1936 int 1937 vop_pathconf_ap(struct vop_pathconf_args *ap) 1938 { 1939 int error; 1940 1941 DO_OPS(ap->a_head.a_ops, error, ap, vop_pathconf); 1942 return(error); 1943 } 1944 1945 int 1946 vop_advlock_ap(struct vop_advlock_args *ap) 1947 { 1948 int error; 1949 1950 DO_OPS(ap->a_head.a_ops, error, ap, vop_advlock); 1951 return(error); 1952 } 1953 1954 int 1955 vop_balloc_ap(struct vop_balloc_args *ap) 1956 { 1957 int error; 1958 1959 DO_OPS(ap->a_head.a_ops, error, ap, vop_balloc); 1960 return(error); 1961 } 1962 1963 int 1964 vop_reallocblks_ap(struct vop_reallocblks_args *ap) 1965 { 1966 int error; 1967 1968 DO_OPS(ap->a_head.a_ops, error, ap, vop_reallocblks); 1969 return(error); 1970 } 1971 1972 int 1973 vop_getpages_ap(struct vop_getpages_args *ap) 1974 { 1975 int error; 1976 1977 DO_OPS(ap->a_head.a_ops, error, ap, vop_getpages); 1978 return(error); 1979 } 1980 1981 int 1982 vop_putpages_ap(struct vop_putpages_args *ap) 1983 { 1984 int error; 1985 1986 DO_OPS(ap->a_head.a_ops, error, ap, vop_putpages); 1987 return(error); 1988 } 1989 1990 int 1991 vop_freeblks_ap(struct vop_freeblks_args *ap) 1992 { 1993 int error; 1994 1995 DO_OPS(ap->a_head.a_ops, error, ap, vop_freeblks); 1996 return(error); 1997 } 1998 1999 int 2000 vop_getacl_ap(struct vop_getacl_args *ap) 2001 { 2002 int error; 2003 2004 DO_OPS(ap->a_head.a_ops, error, ap, vop_getacl); 2005 return(error); 2006 } 2007 2008 int 2009 vop_setacl_ap(struct vop_setacl_args *ap) 2010 { 2011 int error; 2012 2013 DO_OPS(ap->a_head.a_ops, error, ap, vop_setacl); 2014 return(error); 2015 } 2016 2017 int 2018 vop_aclcheck_ap(struct vop_aclcheck_args *ap) 2019 { 2020 int error; 2021 2022 DO_OPS(ap->a_head.a_ops, error, ap, vop_aclcheck); 2023 return(error); 2024 } 2025 2026 int 2027 vop_getextattr_ap(struct vop_getextattr_args *ap) 2028 { 2029 int error; 2030 2031 DO_OPS(ap->a_head.a_ops, error, ap, vop_getextattr); 2032 return(error); 2033 } 2034 2035 int 2036 vop_setextattr_ap(struct vop_setextattr_args *ap) 2037 { 2038 int error; 2039 2040 DO_OPS(ap->a_head.a_ops, error, ap, vop_setextattr); 2041 return(error); 2042 } 2043 2044 int 2045 vop_mountctl_ap(struct vop_mountctl_args *ap) 2046 { 2047 int error; 2048 2049 DO_OPS(ap->a_head.a_ops, error, ap, vop_mountctl); 2050 return(error); 2051 } 2052 2053 int 2054 vop_markatime_ap(struct vop_markatime_args *ap) 2055 { 2056 int error; 2057 2058 DO_OPS(ap->a_head.a_ops, error, ap, vop_markatime); 2059 return(error); 2060 } 2061 2062 int 2063 vop_nresolve_ap(struct vop_nresolve_args *ap) 2064 { 2065 int error; 2066 2067 DO_OPS(ap->a_head.a_ops, error, ap, vop_nresolve); 2068 return(error); 2069 } 2070 2071 int 2072 vop_nlookupdotdot_ap(struct vop_nlookupdotdot_args *ap) 2073 { 2074 int error; 2075 2076 DO_OPS(ap->a_head.a_ops, error, ap, vop_nlookupdotdot); 2077 return(error); 2078 } 2079 2080 int 2081 vop_ncreate_ap(struct vop_ncreate_args *ap) 2082 { 2083 int error; 2084 2085 DO_OPS(ap->a_head.a_ops, error, ap, vop_ncreate); 2086 return(error); 2087 } 2088 2089 int 2090 vop_nmkdir_ap(struct vop_nmkdir_args *ap) 2091 { 2092 int error; 2093 2094 DO_OPS(ap->a_head.a_ops, error, ap, vop_nmkdir); 2095 return(error); 2096 } 2097 2098 int 2099 vop_nmknod_ap(struct vop_nmknod_args *ap) 2100 { 2101 int error; 2102 2103 DO_OPS(ap->a_head.a_ops, error, ap, vop_nmknod); 2104 return(error); 2105 } 2106 2107 int 2108 vop_nlink_ap(struct vop_nlink_args *ap) 2109 { 2110 int error; 2111 2112 DO_OPS(ap->a_head.a_ops, error, ap, vop_nlink); 2113 return(error); 2114 } 2115 2116 int 2117 vop_nsymlink_ap(struct vop_nsymlink_args *ap) 2118 { 2119 int error; 2120 2121 DO_OPS(ap->a_head.a_ops, error, ap, vop_nsymlink); 2122 return(error); 2123 } 2124 2125 int 2126 vop_nwhiteout_ap(struct vop_nwhiteout_args *ap) 2127 { 2128 int error; 2129 2130 DO_OPS(ap->a_head.a_ops, error, ap, vop_nwhiteout); 2131 return(error); 2132 } 2133 2134 int 2135 vop_nremove_ap(struct vop_nremove_args *ap) 2136 { 2137 int error; 2138 2139 DO_OPS(ap->a_head.a_ops, error, ap, vop_nremove); 2140 return(error); 2141 } 2142 2143 int 2144 vop_nrmdir_ap(struct vop_nrmdir_args *ap) 2145 { 2146 int error; 2147 2148 DO_OPS(ap->a_head.a_ops, error, ap, vop_nrmdir); 2149 return(error); 2150 } 2151 2152 int 2153 vop_nrename_ap(struct vop_nrename_args *ap) 2154 { 2155 int error; 2156 2157 DO_OPS(ap->a_head.a_ops, error, ap, vop_nrename); 2158 return(error); 2159 } 2160 2161