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.13 2004/12/29 02:40:02 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, struct file *fp, 1180 const void *ctl, int ctllen, void *buf, int buflen, int *res) 1181 { 1182 struct vop_mountctl_args ap; 1183 int error; 1184 1185 ap.a_head.a_desc = &vop_mountctl_desc; 1186 ap.a_head.a_ops = ops; 1187 ap.a_op = op; 1188 ap.a_ctl = ctl; 1189 ap.a_fp = fp; 1190 ap.a_ctllen = ctllen; 1191 ap.a_buf = buf; 1192 ap.a_buflen = buflen; 1193 ap.a_res = res; 1194 1195 DO_OPS(ops, error, &ap, vop_mountctl); 1196 return(error); 1197 } 1198 1199 /* 1200 * NEW API FUNCTIONS 1201 * 1202 * nresolve takes a locked ncp and a cred and resolves the ncp into a 1203 * positive or negative hit. 1204 * 1205 * The namecache is automatically adjusted by this function. The ncp 1206 * is left locked on return. 1207 */ 1208 int 1209 vop_nresolve(struct vop_ops *ops, struct namecache *ncp, struct ucred *cred) 1210 { 1211 struct vop_nresolve_args ap; 1212 int error; 1213 1214 ap.a_head.a_desc = &vop_nresolve_desc; 1215 ap.a_head.a_ops = ops; 1216 ap.a_ncp = ncp; 1217 ap.a_cred = cred; 1218 1219 DO_OPS(ops, error, &ap, vop_nresolve); 1220 return(error); 1221 } 1222 1223 /* 1224 * nlookupdotdot takes an unlocked directory, dvp, and looks up "..", returning 1225 * a locked parent directory in *vpp. If an error occurs *vpp will be NULL. 1226 */ 1227 int 1228 vop_nlookupdotdot(struct vop_ops *ops, struct vnode *dvp, 1229 struct vnode **vpp, struct ucred *cred) 1230 { 1231 struct vop_nlookupdotdot_args ap; 1232 int error; 1233 1234 ap.a_head.a_desc = &vop_nlookupdotdot_desc; 1235 ap.a_head.a_ops = ops; 1236 ap.a_dvp = dvp; 1237 ap.a_vpp = vpp; 1238 ap.a_cred = cred; 1239 1240 DO_OPS(ops, error, &ap, vop_nlookupdotdot); 1241 return(error); 1242 } 1243 1244 /* 1245 * ncreate takes a locked, resolved ncp that typically represents a negative 1246 * cache hit and creates the file or node specified by the ncp, cred, and 1247 * vattr. If no error occurs a locked vnode is returned in *vpp. 1248 * 1249 * The namecache is automatically adjusted by this function. The ncp 1250 * is left locked on return. 1251 */ 1252 int 1253 vop_ncreate(struct vop_ops *ops, struct namecache *ncp, 1254 struct vnode **vpp, struct ucred *cred, struct vattr *vap) 1255 { 1256 struct vop_ncreate_args ap; 1257 int error; 1258 1259 ap.a_head.a_desc = &vop_ncreate_desc; 1260 ap.a_head.a_ops = ops; 1261 ap.a_ncp = ncp; 1262 ap.a_vpp = vpp; 1263 ap.a_cred = cred; 1264 ap.a_vap = vap; 1265 1266 DO_OPS(ops, error, &ap, vop_ncreate); 1267 return(error); 1268 } 1269 1270 /* 1271 * nmkdir takes a locked, resolved ncp that typically represents a negative 1272 * cache hit and creates the directory specified by the ncp, cred, and 1273 * vattr. If no error occurs a locked vnode is returned in *vpp. 1274 * 1275 * The namecache is automatically adjusted by this function. The ncp 1276 * is left locked on return. 1277 */ 1278 int 1279 vop_nmkdir(struct vop_ops *ops, struct namecache *ncp, 1280 struct vnode **vpp, struct ucred *cred, struct vattr *vap) 1281 { 1282 struct vop_nmkdir_args ap; 1283 int error; 1284 1285 ap.a_head.a_desc = &vop_nmkdir_desc; 1286 ap.a_head.a_ops = ops; 1287 ap.a_ncp = ncp; 1288 ap.a_vpp = vpp; 1289 ap.a_cred = cred; 1290 ap.a_vap = vap; 1291 1292 DO_OPS(ops, error, &ap, vop_nmkdir); 1293 return(error); 1294 } 1295 1296 /* 1297 * nmknod takes a locked, resolved ncp that typically represents a negative 1298 * cache hit and creates the node specified by the ncp, cred, and 1299 * vattr. If no error occurs a locked vnode is returned in *vpp. 1300 * 1301 * The namecache is automatically adjusted by this function. The ncp 1302 * is left locked on return. 1303 */ 1304 int 1305 vop_nmknod(struct vop_ops *ops, struct namecache *ncp, 1306 struct vnode **vpp, struct ucred *cred, struct vattr *vap) 1307 { 1308 struct vop_nmknod_args ap; 1309 int error; 1310 1311 ap.a_head.a_desc = &vop_nmknod_desc; 1312 ap.a_head.a_ops = ops; 1313 ap.a_ncp = ncp; 1314 ap.a_vpp = vpp; 1315 ap.a_cred = cred; 1316 ap.a_vap = vap; 1317 1318 DO_OPS(ops, error, &ap, vop_nmknod); 1319 return(error); 1320 } 1321 1322 /* 1323 * nlink takes a locked, resolved ncp that typically represents a negative 1324 * cache hit and creates the node specified by the ncp, cred, and 1325 * existing vnode. The passed vp must be locked and will remain locked 1326 * on return, as does the ncp, whether an error occurs or not. 1327 * 1328 * The namecache is automatically adjusted by this function. The ncp 1329 * is left locked on return. 1330 */ 1331 int 1332 vop_nlink(struct vop_ops *ops, struct namecache *ncp, 1333 struct vnode *vp, struct ucred *cred) 1334 { 1335 struct vop_nlink_args ap; 1336 int error; 1337 1338 ap.a_head.a_desc = &vop_nlink_desc; 1339 ap.a_head.a_ops = ops; 1340 ap.a_ncp = ncp; 1341 ap.a_vp = vp; 1342 ap.a_cred = cred; 1343 1344 DO_OPS(ops, error, &ap, vop_nlink); 1345 return(error); 1346 } 1347 1348 /* 1349 * nsymlink takes a locked, resolved ncp that typically represents a negative 1350 * cache hit and creates a symbolic link based on cred, vap, and target (the 1351 * contents of the link). If no error occurs a locked vnode is returned in 1352 * *vpp. 1353 * 1354 * The namecache is automatically adjusted by this function. The ncp 1355 * is left locked on return. 1356 */ 1357 int 1358 vop_nsymlink(struct vop_ops *ops, struct namecache *ncp, 1359 struct vnode **vpp, struct ucred *cred, 1360 struct vattr *vap, char *target) 1361 { 1362 struct vop_nsymlink_args ap; 1363 int error; 1364 1365 ap.a_head.a_desc = &vop_nsymlink_desc; 1366 ap.a_head.a_ops = ops; 1367 ap.a_ncp = ncp; 1368 ap.a_vpp = vpp; 1369 ap.a_cred = cred; 1370 ap.a_vap = vap; 1371 ap.a_target = target; 1372 1373 DO_OPS(ops, error, &ap, vop_nsymlink); 1374 return(error); 1375 } 1376 1377 /* 1378 * nwhiteout takes a locked, resolved ncp that can represent a positive or 1379 * negative hit and executes the whiteout function specified in flags. 1380 * 1381 * The namecache is automatically adjusted by this function. The ncp 1382 * is left locked on return. 1383 */ 1384 int 1385 vop_nwhiteout(struct vop_ops *ops, struct namecache *ncp, 1386 struct ucred *cred, int flags) 1387 { 1388 struct vop_nwhiteout_args ap; 1389 int error; 1390 1391 ap.a_head.a_desc = &vop_nwhiteout_desc; 1392 ap.a_head.a_ops = ops; 1393 ap.a_ncp = ncp; 1394 ap.a_cred = cred; 1395 ap.a_flags = flags; 1396 1397 DO_OPS(ops, error, &ap, vop_nwhiteout); 1398 return(error); 1399 } 1400 1401 /* 1402 * nremove takes a locked, resolved ncp that generally represents a 1403 * positive hit and removes the file. 1404 * 1405 * The namecache is automatically adjusted by this function. The ncp 1406 * is left locked on return. 1407 */ 1408 int 1409 vop_nremove(struct vop_ops *ops, struct namecache *ncp, struct ucred *cred) 1410 { 1411 struct vop_nremove_args ap; 1412 int error; 1413 1414 ap.a_head.a_desc = &vop_nremove_desc; 1415 ap.a_head.a_ops = ops; 1416 ap.a_ncp = ncp; 1417 ap.a_cred = cred; 1418 1419 DO_OPS(ops, error, &ap, vop_nremove); 1420 return(error); 1421 } 1422 1423 /* 1424 * nrmdir takes a locked, resolved ncp that generally represents a 1425 * directory and removes the directory. 1426 * 1427 * The namecache is automatically adjusted by this function. The ncp 1428 * is left locked on return. 1429 */ 1430 int 1431 vop_nrmdir(struct vop_ops *ops, struct namecache *ncp, struct ucred *cred) 1432 { 1433 struct vop_nrmdir_args ap; 1434 int error; 1435 1436 ap.a_head.a_desc = &vop_nrmdir_desc; 1437 ap.a_head.a_ops = ops; 1438 ap.a_ncp = ncp; 1439 ap.a_cred = cred; 1440 1441 DO_OPS(ops, error, &ap, vop_nrmdir); 1442 return(error); 1443 } 1444 1445 /* 1446 * nrename takes TWO locked, resolved ncp's and the cred of the caller 1447 * and renames the source ncp to the target ncp. The target ncp may 1448 * represent a positive or negative hit. 1449 * 1450 * The namecache is automatically adjusted by this function. The ncp 1451 * is left locked on return. The source ncp is typically changed to 1452 * a negative cache hit and the target ncp typically takes on the 1453 * source ncp's underlying file. 1454 */ 1455 int 1456 vop_nrename(struct vop_ops *ops, struct namecache *fncp, 1457 struct namecache *tncp, struct ucred *cred) 1458 { 1459 struct vop_nrename_args ap; 1460 int error; 1461 1462 ap.a_head.a_desc = &vop_nrename_desc; 1463 ap.a_head.a_ops = ops; 1464 ap.a_fncp = fncp; 1465 ap.a_tncp = tncp; 1466 ap.a_cred = cred; 1467 1468 DO_OPS(ops, error, &ap, vop_nrename); 1469 return(error); 1470 } 1471 1472 /************************************************************************ 1473 * PRIMARY VNODE OPERATIONS FORWARDING CALLS * 1474 ************************************************************************ 1475 * 1476 * These procedures are called from VFSs such as unionfs and nullfs 1477 * when they wish to forward an operation on one VFS to another. The 1478 * argument structure/message is modified and then directly passed to the 1479 * appropriate routine. This routines may also be called by initiators 1480 * who have an argument structure in hand rather then discreet arguments. 1481 */ 1482 int 1483 vop_vnoperate_ap(struct vop_generic_args *ap) 1484 { 1485 struct vop_ops *ops; 1486 int error; 1487 1488 ops = ap->a_ops; 1489 error = VOCALL(ops, ap); 1490 1491 return (error); 1492 } 1493 1494 /* 1495 * This routine is called by the cache coherency layer to execute the actual 1496 * VFS operation. If a journaling layer is present we call though it, else 1497 * we call the native VOP functions. 1498 */ 1499 int 1500 vop_cache_operate_ap(struct vop_generic_args *ap) 1501 { 1502 struct vop_ops *ops; 1503 int error; 1504 1505 ops = ap->a_ops; 1506 if (ops->vv_mount->mnt_vn_journal_ops) 1507 error = VOCALL(ops->vv_mount->mnt_vn_journal_ops, ap); 1508 else 1509 error = VOCALL(ops->vv_mount->mnt_vn_norm_ops, ap); 1510 return (error); 1511 } 1512 1513 1514 /* 1515 * This routine is called by the journaling layer to execute the actual 1516 * VFS operation. 1517 */ 1518 int 1519 vop_journal_operate_ap(struct vop_generic_args *ap) 1520 { 1521 struct vop_ops *ops; 1522 int error; 1523 1524 ops = ap->a_ops; 1525 error = VOCALL(ops->vv_mount->mnt_vn_norm_ops, ap); 1526 1527 return (error); 1528 } 1529 1530 int 1531 vop_islocked_ap(struct vop_islocked_args *ap) 1532 { 1533 int error; 1534 1535 DO_OPS(ap->a_head.a_ops, error, ap, vop_islocked); 1536 return(error); 1537 } 1538 1539 int 1540 vop_lookup_ap(struct vop_lookup_args *ap) 1541 { 1542 int error; 1543 1544 DO_OPS(ap->a_head.a_ops, error, ap, vop_lookup); 1545 return(error); 1546 } 1547 1548 int 1549 vop_create_ap(struct vop_create_args *ap) 1550 { 1551 int error; 1552 1553 DO_OPS(ap->a_head.a_ops, error, ap, vop_create); 1554 return(error); 1555 } 1556 1557 int 1558 vop_whiteout_ap(struct vop_whiteout_args *ap) 1559 { 1560 int error; 1561 1562 DO_OPS(ap->a_head.a_ops, error, ap, vop_whiteout); 1563 return(error); 1564 } 1565 1566 int 1567 vop_mknod_ap(struct vop_mknod_args *ap) 1568 { 1569 int error; 1570 1571 DO_OPS(ap->a_head.a_ops, error, ap, vop_mknod); 1572 return(error); 1573 } 1574 1575 int 1576 vop_open_ap(struct vop_open_args *ap) 1577 { 1578 int error; 1579 1580 DO_OPS(ap->a_head.a_ops, error, ap, vop_open); 1581 return(error); 1582 } 1583 1584 int 1585 vop_close_ap(struct vop_close_args *ap) 1586 { 1587 int error; 1588 1589 DO_OPS(ap->a_head.a_ops, error, ap, vop_close); 1590 return(error); 1591 } 1592 1593 int 1594 vop_access_ap(struct vop_access_args *ap) 1595 { 1596 int error; 1597 1598 DO_OPS(ap->a_head.a_ops, error, ap, vop_access); 1599 return(error); 1600 } 1601 1602 int 1603 vop_getattr_ap(struct vop_getattr_args *ap) 1604 { 1605 int error; 1606 1607 DO_OPS(ap->a_head.a_ops, error, ap, vop_getattr); 1608 return(error); 1609 } 1610 1611 int 1612 vop_setattr_ap(struct vop_setattr_args *ap) 1613 { 1614 int error; 1615 1616 DO_OPS(ap->a_head.a_ops, error, ap, vop_setattr); 1617 return(error); 1618 } 1619 1620 int 1621 vop_read_ap(struct vop_read_args *ap) 1622 { 1623 int error; 1624 1625 DO_OPS(ap->a_head.a_ops, error, ap, vop_read); 1626 return(error); 1627 } 1628 1629 int 1630 vop_write_ap(struct vop_write_args *ap) 1631 { 1632 int error; 1633 1634 DO_OPS(ap->a_head.a_ops, error, ap, vop_write); 1635 return(error); 1636 } 1637 1638 int 1639 vop_lease_ap(struct vop_lease_args *ap) 1640 { 1641 int error; 1642 1643 DO_OPS(ap->a_head.a_ops, error, ap, vop_lease); 1644 return(error); 1645 } 1646 1647 int 1648 vop_ioctl_ap(struct vop_ioctl_args *ap) 1649 { 1650 int error; 1651 1652 DO_OPS(ap->a_head.a_ops, error, ap, vop_ioctl); 1653 return(error); 1654 } 1655 1656 int 1657 vop_poll_ap(struct vop_poll_args *ap) 1658 { 1659 int error; 1660 1661 DO_OPS(ap->a_head.a_ops, error, ap, vop_poll); 1662 return(error); 1663 } 1664 1665 int 1666 vop_kqfilter_ap(struct vop_kqfilter_args *ap) 1667 { 1668 int error; 1669 1670 DO_OPS(ap->a_head.a_ops, error, ap, vop_kqfilter); 1671 return(error); 1672 } 1673 1674 int 1675 vop_revoke_ap(struct vop_revoke_args *ap) 1676 { 1677 int error; 1678 1679 DO_OPS(ap->a_head.a_ops, error, ap, vop_revoke); 1680 return(error); 1681 } 1682 1683 int 1684 vop_mmap_ap(struct vop_mmap_args *ap) 1685 { 1686 int error; 1687 1688 DO_OPS(ap->a_head.a_ops, error, ap, vop_mmap); 1689 return(error); 1690 } 1691 1692 int 1693 vop_fsync_ap(struct vop_fsync_args *ap) 1694 { 1695 int error; 1696 1697 DO_OPS(ap->a_head.a_ops, error, ap, vop_fsync); 1698 return(error); 1699 } 1700 1701 int 1702 vop_remove_ap(struct vop_remove_args *ap) 1703 { 1704 int error; 1705 1706 DO_OPS(ap->a_head.a_ops, error, ap, vop_remove); 1707 return(error); 1708 } 1709 1710 int 1711 vop_link_ap(struct vop_link_args *ap) 1712 { 1713 int error; 1714 1715 DO_OPS(ap->a_head.a_ops, error, ap, vop_link); 1716 return(error); 1717 } 1718 1719 int 1720 vop_rename_ap(struct vop_rename_args *ap) 1721 { 1722 int error; 1723 1724 DO_OPS(ap->a_head.a_ops, error, ap, vop_rename); 1725 return(error); 1726 } 1727 1728 int 1729 vop_mkdir_ap(struct vop_mkdir_args *ap) 1730 { 1731 int error; 1732 1733 DO_OPS(ap->a_head.a_ops, error, ap, vop_mkdir); 1734 return(error); 1735 } 1736 1737 int 1738 vop_rmdir_ap(struct vop_rmdir_args *ap) 1739 { 1740 int error; 1741 1742 DO_OPS(ap->a_head.a_ops, error, ap, vop_rmdir); 1743 return(error); 1744 } 1745 1746 int 1747 vop_symlink_ap(struct vop_symlink_args *ap) 1748 { 1749 int error; 1750 1751 DO_OPS(ap->a_head.a_ops, error, ap, vop_symlink); 1752 return(error); 1753 } 1754 1755 int 1756 vop_readdir_ap(struct vop_readdir_args *ap) 1757 { 1758 int error; 1759 1760 DO_OPS(ap->a_head.a_ops, error, ap, vop_readdir); 1761 return(error); 1762 } 1763 1764 int 1765 vop_readlink_ap(struct vop_readlink_args *ap) 1766 { 1767 int error; 1768 1769 DO_OPS(ap->a_head.a_ops, error, ap, vop_readlink); 1770 return(error); 1771 } 1772 1773 int 1774 vop_inactive_ap(struct vop_inactive_args *ap) 1775 { 1776 int error; 1777 1778 DO_OPS(ap->a_head.a_ops, error, ap, vop_inactive); 1779 return(error); 1780 } 1781 1782 int 1783 vop_reclaim_ap(struct vop_reclaim_args *ap) 1784 { 1785 int error; 1786 1787 DO_OPS(ap->a_head.a_ops, error, ap, vop_reclaim); 1788 return(error); 1789 } 1790 1791 int 1792 vop_lock_ap(struct vop_lock_args *ap) 1793 { 1794 int error; 1795 1796 DO_OPS(ap->a_head.a_ops, error, ap, vop_lock); 1797 return(error); 1798 } 1799 1800 int 1801 vop_unlock_ap(struct vop_unlock_args *ap) 1802 { 1803 int error; 1804 1805 DO_OPS(ap->a_head.a_ops, error, ap, vop_unlock); 1806 return(error); 1807 } 1808 1809 int 1810 vop_bmap_ap(struct vop_bmap_args *ap) 1811 { 1812 int error; 1813 1814 DO_OPS(ap->a_head.a_ops, error, ap, vop_bmap); 1815 return(error); 1816 } 1817 1818 int 1819 vop_strategy_ap(struct vop_strategy_args *ap) 1820 { 1821 int error; 1822 1823 DO_OPS(ap->a_head.a_ops, error, ap, vop_strategy); 1824 return(error); 1825 } 1826 1827 int 1828 vop_print_ap(struct vop_print_args *ap) 1829 { 1830 int error; 1831 1832 DO_OPS(ap->a_head.a_ops, error, ap, vop_print); 1833 return(error); 1834 } 1835 1836 int 1837 vop_pathconf_ap(struct vop_pathconf_args *ap) 1838 { 1839 int error; 1840 1841 DO_OPS(ap->a_head.a_ops, error, ap, vop_pathconf); 1842 return(error); 1843 } 1844 1845 int 1846 vop_advlock_ap(struct vop_advlock_args *ap) 1847 { 1848 int error; 1849 1850 DO_OPS(ap->a_head.a_ops, error, ap, vop_advlock); 1851 return(error); 1852 } 1853 1854 int 1855 vop_balloc_ap(struct vop_balloc_args *ap) 1856 { 1857 int error; 1858 1859 DO_OPS(ap->a_head.a_ops, error, ap, vop_balloc); 1860 return(error); 1861 } 1862 1863 int 1864 vop_reallocblks_ap(struct vop_reallocblks_args *ap) 1865 { 1866 int error; 1867 1868 DO_OPS(ap->a_head.a_ops, error, ap, vop_reallocblks); 1869 return(error); 1870 } 1871 1872 int 1873 vop_getpages_ap(struct vop_getpages_args *ap) 1874 { 1875 int error; 1876 1877 DO_OPS(ap->a_head.a_ops, error, ap, vop_getpages); 1878 return(error); 1879 } 1880 1881 int 1882 vop_putpages_ap(struct vop_putpages_args *ap) 1883 { 1884 int error; 1885 1886 DO_OPS(ap->a_head.a_ops, error, ap, vop_putpages); 1887 return(error); 1888 } 1889 1890 int 1891 vop_freeblks_ap(struct vop_freeblks_args *ap) 1892 { 1893 int error; 1894 1895 DO_OPS(ap->a_head.a_ops, error, ap, vop_freeblks); 1896 return(error); 1897 } 1898 1899 int 1900 vop_bwrite_ap(struct vop_bwrite_args *ap) 1901 { 1902 int error; 1903 1904 DO_OPS(ap->a_head.a_ops, error, ap, vop_bwrite); 1905 return(error); 1906 } 1907 1908 int 1909 vop_getacl_ap(struct vop_getacl_args *ap) 1910 { 1911 int error; 1912 1913 DO_OPS(ap->a_head.a_ops, error, ap, vop_getacl); 1914 return(error); 1915 } 1916 1917 int 1918 vop_setacl_ap(struct vop_setacl_args *ap) 1919 { 1920 int error; 1921 1922 DO_OPS(ap->a_head.a_ops, error, ap, vop_setacl); 1923 return(error); 1924 } 1925 1926 int 1927 vop_aclcheck_ap(struct vop_aclcheck_args *ap) 1928 { 1929 int error; 1930 1931 DO_OPS(ap->a_head.a_ops, error, ap, vop_aclcheck); 1932 return(error); 1933 } 1934 1935 int 1936 vop_getextattr_ap(struct vop_getextattr_args *ap) 1937 { 1938 int error; 1939 1940 DO_OPS(ap->a_head.a_ops, error, ap, vop_getextattr); 1941 return(error); 1942 } 1943 1944 int 1945 vop_setextattr_ap(struct vop_setextattr_args *ap) 1946 { 1947 int error; 1948 1949 DO_OPS(ap->a_head.a_ops, error, ap, vop_setextattr); 1950 return(error); 1951 } 1952 1953 int 1954 vop_createvobject_ap(struct vop_createvobject_args *ap) 1955 { 1956 int error; 1957 1958 DO_OPS(ap->a_head.a_ops, error, ap, vop_createvobject); 1959 return(error); 1960 } 1961 1962 int 1963 vop_destroyvobject_ap(struct vop_destroyvobject_args *ap) 1964 { 1965 int error; 1966 1967 DO_OPS(ap->a_head.a_ops, error, ap, vop_destroyvobject); 1968 return(error); 1969 } 1970 1971 int 1972 vop_getvobject_ap(struct vop_getvobject_args *ap) 1973 { 1974 int error; 1975 1976 DO_OPS(ap->a_head.a_ops, error, ap, vop_getvobject); 1977 return(error); 1978 } 1979 1980 int 1981 vop_mountctl_ap(struct vop_mountctl_args *ap) 1982 { 1983 int error; 1984 1985 DO_OPS(ap->a_head.a_ops, error, ap, vop_mountctl); 1986 return(error); 1987 } 1988 1989 int 1990 vop_nresolve_ap(struct vop_nresolve_args *ap) 1991 { 1992 int error; 1993 1994 DO_OPS(ap->a_head.a_ops, error, ap, vop_nresolve); 1995 return(error); 1996 } 1997 1998 int 1999 vop_nlookupdotdot_ap(struct vop_nlookupdotdot_args *ap) 2000 { 2001 int error; 2002 2003 DO_OPS(ap->a_head.a_ops, error, ap, vop_nlookupdotdot); 2004 return(error); 2005 } 2006 2007 int 2008 vop_ncreate_ap(struct vop_ncreate_args *ap) 2009 { 2010 int error; 2011 2012 DO_OPS(ap->a_head.a_ops, error, ap, vop_ncreate); 2013 return(error); 2014 } 2015 2016 int 2017 vop_nmkdir_ap(struct vop_nmkdir_args *ap) 2018 { 2019 int error; 2020 2021 DO_OPS(ap->a_head.a_ops, error, ap, vop_nmkdir); 2022 return(error); 2023 } 2024 2025 int 2026 vop_nmknod_ap(struct vop_nmknod_args *ap) 2027 { 2028 int error; 2029 2030 DO_OPS(ap->a_head.a_ops, error, ap, vop_nmknod); 2031 return(error); 2032 } 2033 2034 int 2035 vop_nlink_ap(struct vop_nlink_args *ap) 2036 { 2037 int error; 2038 2039 DO_OPS(ap->a_head.a_ops, error, ap, vop_nlink); 2040 return(error); 2041 } 2042 2043 int 2044 vop_nsymlink_ap(struct vop_nsymlink_args *ap) 2045 { 2046 int error; 2047 2048 DO_OPS(ap->a_head.a_ops, error, ap, vop_nsymlink); 2049 return(error); 2050 } 2051 2052 int 2053 vop_nwhiteout_ap(struct vop_nwhiteout_args *ap) 2054 { 2055 int error; 2056 2057 DO_OPS(ap->a_head.a_ops, error, ap, vop_nwhiteout); 2058 return(error); 2059 } 2060 2061 int 2062 vop_nremove_ap(struct vop_nremove_args *ap) 2063 { 2064 int error; 2065 2066 DO_OPS(ap->a_head.a_ops, error, ap, vop_nremove); 2067 return(error); 2068 } 2069 2070 int 2071 vop_nrmdir_ap(struct vop_nrmdir_args *ap) 2072 { 2073 int error; 2074 2075 DO_OPS(ap->a_head.a_ops, error, ap, vop_nrmdir); 2076 return(error); 2077 } 2078 2079 int 2080 vop_nrename_ap(struct vop_nrename_args *ap) 2081 { 2082 int error; 2083 2084 DO_OPS(ap->a_head.a_ops, error, ap, vop_nrename); 2085 return(error); 2086 } 2087 2088