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