1 /* $NetBSD: vnode_if.c,v 1.115 2021/10/20 03:13:14 thorpej Exp $ */ 2 3 /* 4 * Warning: DO NOT EDIT! This file is automatically generated! 5 * (Modifications made here may easily be lost!) 6 * 7 * Created from the file: 8 * NetBSD: vnode_if.src,v 1.83 2021/10/20 03:08:18 thorpej Exp 9 * by the script: 10 * NetBSD: vnode_if.sh,v 1.72 2021/10/20 03:08:18 thorpej Exp 11 */ 12 13 /* 14 * Copyright (c) 1992, 1993, 1994, 1995 15 * The Regents of the University of California. All rights reserved. 16 * 17 * Redistribution and use in source and binary forms, with or without 18 * modification, are permitted provided that the following conditions 19 * are met: 20 * 1. Redistributions of source code must retain the above copyright 21 * notice, this list of conditions and the following disclaimer. 22 * 2. Redistributions in binary form must reproduce the above copyright 23 * notice, this list of conditions and the following disclaimer in the 24 * documentation and/or other materials provided with the distribution. 25 * 3. Neither the name of the University nor the names of its contributors 26 * may be used to endorse or promote products derived from this software 27 * without specific prior written permission. 28 * 29 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 30 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 31 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 32 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 33 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 34 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 35 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 36 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 37 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 38 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 39 * SUCH DAMAGE. 40 */ 41 42 #include <sys/cdefs.h> 43 __KERNEL_RCSID(0, "$NetBSD: vnode_if.c,v 1.115 2021/10/20 03:13:14 thorpej Exp $"); 44 45 #include <sys/param.h> 46 #include <sys/mount.h> 47 #include <sys/buf.h> 48 #include <sys/fcntl.h> 49 #include <sys/vnode.h> 50 #include <sys/lock.h> 51 #include <sys/fstrans.h> 52 53 enum fst_op { FST_NO, FST_YES, FST_LAZY, FST_TRY }; 54 55 static inline int 56 vop_pre(vnode_t *vp, struct mount **mp, bool *mpsafe, enum fst_op op) 57 { 58 int error; 59 60 *mpsafe = (vp->v_vflag & VV_MPSAFE); 61 62 if (!*mpsafe) { 63 KERNEL_LOCK(1, curlwp); 64 } 65 66 if (op == FST_YES || op == FST_LAZY || op == FST_TRY) { 67 for (;;) { 68 *mp = vp->v_mount; 69 if (op == FST_TRY) { 70 error = fstrans_start_nowait(*mp); 71 if (error) { 72 if (!*mpsafe) { 73 KERNEL_UNLOCK_ONE(curlwp); 74 } 75 return error; 76 } 77 } else if (op == FST_LAZY) { 78 fstrans_start_lazy(*mp); 79 } else { 80 fstrans_start(*mp); 81 } 82 if (__predict_true(*mp == vp->v_mount)) 83 break; 84 fstrans_done(*mp); 85 } 86 } else { 87 *mp = vp->v_mount; 88 } 89 90 return 0; 91 } 92 93 static inline u_quad_t 94 vop_pre_get_size(struct vnode *vp) 95 { 96 mutex_enter(vp->v_interlock); 97 KASSERT(vp->v_size != VSIZENOTSET); 98 u_quad_t rv = (u_quad_t)vp->v_size; 99 mutex_exit(vp->v_interlock); 100 101 return rv; 102 } 103 104 /* 105 * VOP_RMDIR(), VOP_REMOVE(), and VOP_RENAME() need special handling 106 * because they each drop the caller's references on one or more of 107 * their arguments. While there must be an open file descriptor in 108 * associated with a vnode in order for knotes to be attached to it, 109 * that status could change during the course of the operation. So, 110 * for the vnode arguments that are WILLRELE or WILLPUT, we check 111 * pre-op if there are registered knotes, take a hold count if so, 112 * and post-op release the hold after activating any knotes still 113 * associated with the vnode. 114 */ 115 116 #define VOP_POST_KNOTE(thisvp, e, n) \ 117 do { \ 118 if (__predict_true((e) == 0)) { \ 119 /* \ 120 * VN_KNOTE() does the VN_KEVENT_INTEREST() \ 121 * check for us. \ 122 */ \ 123 VN_KNOTE((thisvp), (n)); \ 124 } \ 125 } while (/*CONSTCOND*/0) 126 127 #define VOP_POST_KNOTE_HELD(thisvp, e, n) \ 128 do { \ 129 /* \ 130 * We don't perform a VN_KEVENT_INTEREST() check here; it \ 131 * was already performed when we did the pre-op work that \ 132 * caused the vnode to be held in the first place. \ 133 */ \ 134 mutex_enter((thisvp)->v_interlock); \ 135 if (__predict_true((e) == 0)) { \ 136 knote(&(thisvp)->v_klist, (n)); \ 137 } \ 138 holdrelel((thisvp)); \ 139 mutex_exit((thisvp)->v_interlock); \ 140 /* \ 141 * thisvp might be gone now! Don't touch! \ 142 */ \ 143 } while (/*CONSTCOND*/0) 144 145 #define vop_create_post(ap, e) \ 146 VOP_POST_KNOTE((ap)->a_dvp, (e), NOTE_WRITE) 147 148 #define vop_mknod_post(ap, e) \ 149 VOP_POST_KNOTE((ap)->a_dvp, (e), NOTE_WRITE) 150 151 #define vop_setattr_pre(ap) \ 152 u_quad_t osize = 0; \ 153 long vp_events = \ 154 VN_KEVENT_INTEREST((ap)->a_vp, NOTE_ATTRIB | NOTE_EXTEND) \ 155 ? NOTE_ATTRIB : 0; \ 156 bool check_extend = false; \ 157 if (__predict_false(vp_events != 0 && \ 158 (ap)->a_vap->va_size != VNOVALSIZE)) { \ 159 check_extend = true; \ 160 osize = vop_pre_get_size((ap)->a_vp); \ 161 } 162 163 #define vop_setattr_post(ap, e) \ 164 do { \ 165 if (__predict_false(vp_events != 0)) { \ 166 if (__predict_false(check_extend && \ 167 (ap)->a_vap->va_size > osize)) { \ 168 vp_events |= NOTE_EXTEND; \ 169 } \ 170 VOP_POST_KNOTE((ap)->a_vp, (e), vp_events); \ 171 } \ 172 } while (/*CONSTCOND*/0) 173 174 #define vop_setacl_post(ap, e) \ 175 VOP_POST_KNOTE((ap)->a_vp, (e), NOTE_ATTRIB) 176 177 #define vop_link_post(ap, e) \ 178 do { \ 179 VOP_POST_KNOTE((ap)->a_dvp, (e), NOTE_WRITE); \ 180 VOP_POST_KNOTE((ap)->a_vp, (e), NOTE_LINK); \ 181 } while (/*CONSTCOND*/0) 182 183 #define vop_mkdir_post(ap, e) \ 184 VOP_POST_KNOTE((ap)->a_dvp, (e), NOTE_WRITE | NOTE_LINK) 185 186 #define vop_remove_pre_common(ap) \ 187 bool post_event_vp = \ 188 VN_KEVENT_INTEREST((ap)->a_vp, NOTE_DELETE | NOTE_LINK); \ 189 if (__predict_false(post_event_vp)) { \ 190 vhold((ap)->a_vp); \ 191 } 192 193 #define vop_remove_post_common(ap, e, dn, lc) \ 194 do { \ 195 VOP_POST_KNOTE((ap)->a_dvp, (e), (dn)); \ 196 if (__predict_false(post_event_vp)) { \ 197 VOP_POST_KNOTE_HELD((ap)->a_vp, (e), \ 198 (lc) ? NOTE_LINK : NOTE_DELETE); \ 199 } \ 200 } while (/*CONSTCOND*/0) 201 202 /* 203 * One could make the argument that VOP_REMOVE() should send NOTE_LINK 204 * on vp if the resulting link count is not zero, but that's not what 205 * the documentation says. 206 * 207 * We could change this easily by passing ap->ctx_vp_new_nlink to 208 * vop_remove_post_common(). 209 */ 210 #define vop_remove_pre(ap) \ 211 vop_remove_pre_common((ap)); \ 212 /* \ 213 * We will assume that the file being removed is deleted unless \ 214 * the file system tells us otherwise by updating vp_new_nlink. \ 215 */ \ 216 (ap)->ctx_vp_new_nlink = 0; 217 218 #define vop_remove_post(ap, e) \ 219 vop_remove_post_common((ap), (e), NOTE_WRITE, 0) 220 221 #define vop_rmdir_pre(ap) \ 222 vop_remove_pre_common(ap) 223 224 #define vop_rmdir_post(ap, e) \ 225 vop_remove_post_common((ap), (e), NOTE_WRITE | NOTE_LINK, 0) 226 227 #define vop_symlink_post(ap, e) \ 228 VOP_POST_KNOTE((ap)->a_dvp, (e), NOTE_WRITE) 229 230 #define vop_open_post(ap, e) \ 231 VOP_POST_KNOTE((ap)->a_vp, (e), NOTE_OPEN) 232 233 #define vop_close_post(ap, e) \ 234 do { \ 235 extern int (**dead_vnodeop_p)(void *); \ 236 \ 237 /* See the definition of VN_KNOTE() in <sys/vnode.h>. */ \ 238 if (__predict_false(VN_KEVENT_INTEREST((ap)->a_vp, \ 239 NOTE_CLOSE_WRITE | NOTE_CLOSE) && (e) == 0)) { \ 240 struct vnode *thisvp = (ap)->a_vp; \ 241 mutex_enter(thisvp->v_interlock); \ 242 /* \ 243 * Don't send NOTE_CLOSE when closing a vnode that's \ 244 * been reclaimed or otherwise revoked; a NOTE_REVOKE \ 245 * has already been sent, and this close is effectively \ 246 * meaningless from the watcher's perspective. \ 247 */ \ 248 if (__predict_true(thisvp->v_op != dead_vnodeop_p)) { \ 249 knote(&thisvp->v_klist, \ 250 ((ap)->a_fflag & FWRITE) \ 251 ? NOTE_CLOSE_WRITE : NOTE_CLOSE); \ 252 } \ 253 mutex_exit(thisvp->v_interlock); \ 254 } \ 255 } while (/*CONSTCOND*/0) 256 257 #define vop_read_post(ap, e) \ 258 VOP_POST_KNOTE((ap)->a_vp, (e), NOTE_READ) 259 260 #define vop_write_pre(ap) \ 261 off_t ooffset = 0, noffset = 0; \ 262 u_quad_t osize = 0; \ 263 long vp_events = \ 264 VN_KEVENT_INTEREST((ap)->a_vp, NOTE_WRITE | NOTE_EXTEND) \ 265 ? NOTE_WRITE : 0; \ 266 if (__predict_false(vp_events != 0)) { \ 267 ooffset = (ap)->a_uio->uio_offset; \ 268 osize = vop_pre_get_size((ap)->a_vp); \ 269 } 270 271 #define vop_write_post(ap, e) \ 272 do { \ 273 /* \ 274 * If any data was written, we'll post an event, even if \ 275 * there was an error. \ 276 */ \ 277 noffset = (ap)->a_uio->uio_offset; \ 278 if (__predict_false(vp_events != 0 && noffset > ooffset)) { \ 279 if (noffset > osize) { \ 280 vp_events |= NOTE_EXTEND; \ 281 } \ 282 VN_KNOTE((ap)->a_vp, vp_events); \ 283 } \ 284 } while (/*CONSTCOND*/0) 285 286 static inline void 287 vop_post(vnode_t *vp, struct mount *mp, bool mpsafe, enum fst_op op) 288 { 289 290 if (op == FST_YES || op == FST_LAZY) { 291 fstrans_done(mp); 292 } 293 294 if (!mpsafe) { 295 KERNEL_UNLOCK_ONE(curlwp); 296 } 297 } 298 299 const struct vnodeop_desc vop_default_desc = { 300 0, 301 "default", 302 0, 303 NULL, 304 VDESC_NO_OFFSET, 305 VDESC_NO_OFFSET, 306 VDESC_NO_OFFSET, 307 }; 308 309 310 const int vop_bwrite_vp_offsets[] = { 311 VOPARG_OFFSETOF(struct vop_bwrite_args,a_vp), 312 VDESC_NO_OFFSET 313 }; 314 const struct vnodeop_desc vop_bwrite_desc = { 315 VOP_BWRITE_DESCOFFSET, 316 "vop_bwrite", 317 0, 318 vop_bwrite_vp_offsets, 319 VDESC_NO_OFFSET, 320 VDESC_NO_OFFSET, 321 VDESC_NO_OFFSET, 322 }; 323 int 324 VOP_BWRITE(struct vnode *vp, 325 struct buf *bp) 326 { 327 int error; 328 bool mpsafe; 329 struct vop_bwrite_args a; 330 struct mount *mp; 331 a.a_desc = VDESC(vop_bwrite); 332 a.a_vp = vp; 333 a.a_bp = bp; 334 error = vop_pre(vp, &mp, &mpsafe, FST_YES); 335 if (error) 336 return error; 337 error = (VCALL(vp, VOFFSET(vop_bwrite), &a)); 338 vop_post(vp, mp, mpsafe, FST_YES); 339 return error; 340 } 341 342 const int vop_parsepath_vp_offsets[] = { 343 VOPARG_OFFSETOF(struct vop_parsepath_args,a_dvp), 344 VDESC_NO_OFFSET 345 }; 346 const struct vnodeop_desc vop_parsepath_desc = { 347 VOP_PARSEPATH_DESCOFFSET, 348 "vop_parsepath", 349 0, 350 vop_parsepath_vp_offsets, 351 VDESC_NO_OFFSET, 352 VDESC_NO_OFFSET, 353 VDESC_NO_OFFSET, 354 }; 355 int 356 VOP_PARSEPATH(struct vnode *dvp, 357 const char *name, 358 size_t *retval) 359 { 360 int error; 361 bool mpsafe; 362 struct vop_parsepath_args a; 363 struct mount *mp; 364 a.a_desc = VDESC(vop_parsepath); 365 a.a_dvp = dvp; 366 a.a_name = name; 367 a.a_retval = retval; 368 error = vop_pre(dvp, &mp, &mpsafe, FST_NO); 369 if (error) 370 return error; 371 error = (VCALL(dvp, VOFFSET(vop_parsepath), &a)); 372 vop_post(dvp, mp, mpsafe, FST_NO); 373 return error; 374 } 375 376 const int vop_lookup_vp_offsets[] = { 377 VOPARG_OFFSETOF(struct vop_lookup_v2_args,a_dvp), 378 VDESC_NO_OFFSET 379 }; 380 const struct vnodeop_desc vop_lookup_desc = { 381 VOP_LOOKUP_DESCOFFSET, 382 "vop_lookup", 383 0, 384 vop_lookup_vp_offsets, 385 VOPARG_OFFSETOF(struct vop_lookup_v2_args, a_vpp), 386 VDESC_NO_OFFSET, 387 VOPARG_OFFSETOF(struct vop_lookup_v2_args, a_cnp), 388 }; 389 int 390 VOP_LOOKUP(struct vnode *dvp, 391 struct vnode **vpp, 392 struct componentname *cnp) 393 { 394 int error; 395 bool mpsafe; 396 struct vop_lookup_v2_args a; 397 struct mount *mp; 398 a.a_desc = VDESC(vop_lookup); 399 a.a_dvp = dvp; 400 a.a_vpp = vpp; 401 a.a_cnp = cnp; 402 error = vop_pre(dvp, &mp, &mpsafe, FST_NO); 403 if (error) 404 return error; 405 error = (VCALL(dvp, VOFFSET(vop_lookup), &a)); 406 vop_post(dvp, mp, mpsafe, FST_NO); 407 #ifdef DIAGNOSTIC 408 if (error == 0) 409 KASSERT((*vpp)->v_size != VSIZENOTSET 410 && (*vpp)->v_writesize != VSIZENOTSET); 411 #endif /* DIAGNOSTIC */ 412 return error; 413 } 414 415 const int vop_create_vp_offsets[] = { 416 VOPARG_OFFSETOF(struct vop_create_v3_args,a_dvp), 417 VDESC_NO_OFFSET 418 }; 419 const struct vnodeop_desc vop_create_desc = { 420 VOP_CREATE_DESCOFFSET, 421 "vop_create", 422 0, 423 vop_create_vp_offsets, 424 VOPARG_OFFSETOF(struct vop_create_v3_args, a_vpp), 425 VDESC_NO_OFFSET, 426 VOPARG_OFFSETOF(struct vop_create_v3_args, a_cnp), 427 }; 428 int 429 VOP_CREATE(struct vnode *dvp, 430 struct vnode **vpp, 431 struct componentname *cnp, 432 struct vattr *vap) 433 { 434 int error; 435 bool mpsafe; 436 struct vop_create_v3_args a; 437 struct mount *mp; 438 a.a_desc = VDESC(vop_create); 439 a.a_dvp = dvp; 440 a.a_vpp = vpp; 441 a.a_cnp = cnp; 442 a.a_vap = vap; 443 error = vop_pre(dvp, &mp, &mpsafe, FST_NO); 444 if (error) 445 return error; 446 error = (VCALL(dvp, VOFFSET(vop_create), &a)); 447 vop_post(dvp, mp, mpsafe, FST_NO); 448 vop_create_post(&a, error); 449 #ifdef DIAGNOSTIC 450 if (error == 0) 451 KASSERT((*vpp)->v_size != VSIZENOTSET 452 && (*vpp)->v_writesize != VSIZENOTSET); 453 #endif /* DIAGNOSTIC */ 454 return error; 455 } 456 457 const int vop_mknod_vp_offsets[] = { 458 VOPARG_OFFSETOF(struct vop_mknod_v3_args,a_dvp), 459 VDESC_NO_OFFSET 460 }; 461 const struct vnodeop_desc vop_mknod_desc = { 462 VOP_MKNOD_DESCOFFSET, 463 "vop_mknod", 464 0, 465 vop_mknod_vp_offsets, 466 VOPARG_OFFSETOF(struct vop_mknod_v3_args, a_vpp), 467 VDESC_NO_OFFSET, 468 VOPARG_OFFSETOF(struct vop_mknod_v3_args, a_cnp), 469 }; 470 int 471 VOP_MKNOD(struct vnode *dvp, 472 struct vnode **vpp, 473 struct componentname *cnp, 474 struct vattr *vap) 475 { 476 int error; 477 bool mpsafe; 478 struct vop_mknod_v3_args a; 479 struct mount *mp; 480 a.a_desc = VDESC(vop_mknod); 481 a.a_dvp = dvp; 482 a.a_vpp = vpp; 483 a.a_cnp = cnp; 484 a.a_vap = vap; 485 error = vop_pre(dvp, &mp, &mpsafe, FST_NO); 486 if (error) 487 return error; 488 error = (VCALL(dvp, VOFFSET(vop_mknod), &a)); 489 vop_post(dvp, mp, mpsafe, FST_NO); 490 vop_mknod_post(&a, error); 491 #ifdef DIAGNOSTIC 492 if (error == 0) 493 KASSERT((*vpp)->v_size != VSIZENOTSET 494 && (*vpp)->v_writesize != VSIZENOTSET); 495 #endif /* DIAGNOSTIC */ 496 return error; 497 } 498 499 const int vop_open_vp_offsets[] = { 500 VOPARG_OFFSETOF(struct vop_open_args,a_vp), 501 VDESC_NO_OFFSET 502 }; 503 const struct vnodeop_desc vop_open_desc = { 504 VOP_OPEN_DESCOFFSET, 505 "vop_open", 506 0, 507 vop_open_vp_offsets, 508 VDESC_NO_OFFSET, 509 VOPARG_OFFSETOF(struct vop_open_args, a_cred), 510 VDESC_NO_OFFSET, 511 }; 512 int 513 VOP_OPEN(struct vnode *vp, 514 int mode, 515 kauth_cred_t cred) 516 { 517 int error; 518 bool mpsafe; 519 struct vop_open_args a; 520 struct mount *mp; 521 a.a_desc = VDESC(vop_open); 522 a.a_vp = vp; 523 a.a_mode = mode; 524 a.a_cred = cred; 525 error = vop_pre(vp, &mp, &mpsafe, FST_NO); 526 if (error) 527 return error; 528 error = (VCALL(vp, VOFFSET(vop_open), &a)); 529 vop_post(vp, mp, mpsafe, FST_NO); 530 vop_open_post(&a, error); 531 return error; 532 } 533 534 const int vop_close_vp_offsets[] = { 535 VOPARG_OFFSETOF(struct vop_close_args,a_vp), 536 VDESC_NO_OFFSET 537 }; 538 const struct vnodeop_desc vop_close_desc = { 539 VOP_CLOSE_DESCOFFSET, 540 "vop_close", 541 0, 542 vop_close_vp_offsets, 543 VDESC_NO_OFFSET, 544 VOPARG_OFFSETOF(struct vop_close_args, a_cred), 545 VDESC_NO_OFFSET, 546 }; 547 int 548 VOP_CLOSE(struct vnode *vp, 549 int fflag, 550 kauth_cred_t cred) 551 { 552 int error; 553 bool mpsafe; 554 struct vop_close_args a; 555 struct mount *mp; 556 a.a_desc = VDESC(vop_close); 557 a.a_vp = vp; 558 a.a_fflag = fflag; 559 a.a_cred = cred; 560 error = vop_pre(vp, &mp, &mpsafe, FST_NO); 561 if (error) 562 return error; 563 error = (VCALL(vp, VOFFSET(vop_close), &a)); 564 vop_post(vp, mp, mpsafe, FST_NO); 565 vop_close_post(&a, error); 566 return error; 567 } 568 569 const int vop_access_vp_offsets[] = { 570 VOPARG_OFFSETOF(struct vop_access_args,a_vp), 571 VDESC_NO_OFFSET 572 }; 573 const struct vnodeop_desc vop_access_desc = { 574 VOP_ACCESS_DESCOFFSET, 575 "vop_access", 576 0, 577 vop_access_vp_offsets, 578 VDESC_NO_OFFSET, 579 VOPARG_OFFSETOF(struct vop_access_args, a_cred), 580 VDESC_NO_OFFSET, 581 }; 582 int 583 VOP_ACCESS(struct vnode *vp, 584 accmode_t accmode, 585 kauth_cred_t cred) 586 { 587 int error; 588 bool mpsafe; 589 struct vop_access_args a; 590 struct mount *mp; 591 a.a_desc = VDESC(vop_access); 592 a.a_vp = vp; 593 a.a_accmode = accmode; 594 a.a_cred = cred; 595 error = vop_pre(vp, &mp, &mpsafe, FST_NO); 596 if (error) 597 return error; 598 error = (VCALL(vp, VOFFSET(vop_access), &a)); 599 vop_post(vp, mp, mpsafe, FST_NO); 600 return error; 601 } 602 603 const int vop_accessx_vp_offsets[] = { 604 VOPARG_OFFSETOF(struct vop_accessx_args,a_vp), 605 VDESC_NO_OFFSET 606 }; 607 const struct vnodeop_desc vop_accessx_desc = { 608 VOP_ACCESSX_DESCOFFSET, 609 "vop_accessx", 610 0, 611 vop_accessx_vp_offsets, 612 VDESC_NO_OFFSET, 613 VOPARG_OFFSETOF(struct vop_accessx_args, a_cred), 614 VDESC_NO_OFFSET, 615 }; 616 int 617 VOP_ACCESSX(struct vnode *vp, 618 accmode_t accmode, 619 kauth_cred_t cred) 620 { 621 int error; 622 bool mpsafe; 623 struct vop_accessx_args a; 624 struct mount *mp; 625 a.a_desc = VDESC(vop_accessx); 626 a.a_vp = vp; 627 a.a_accmode = accmode; 628 a.a_cred = cred; 629 error = vop_pre(vp, &mp, &mpsafe, FST_NO); 630 if (error) 631 return error; 632 error = (VCALL(vp, VOFFSET(vop_accessx), &a)); 633 vop_post(vp, mp, mpsafe, FST_NO); 634 return error; 635 } 636 637 const int vop_getattr_vp_offsets[] = { 638 VOPARG_OFFSETOF(struct vop_getattr_args,a_vp), 639 VDESC_NO_OFFSET 640 }; 641 const struct vnodeop_desc vop_getattr_desc = { 642 VOP_GETATTR_DESCOFFSET, 643 "vop_getattr", 644 0, 645 vop_getattr_vp_offsets, 646 VDESC_NO_OFFSET, 647 VOPARG_OFFSETOF(struct vop_getattr_args, a_cred), 648 VDESC_NO_OFFSET, 649 }; 650 int 651 VOP_GETATTR(struct vnode *vp, 652 struct vattr *vap, 653 kauth_cred_t cred) 654 { 655 int error; 656 bool mpsafe; 657 struct vop_getattr_args a; 658 struct mount *mp; 659 a.a_desc = VDESC(vop_getattr); 660 a.a_vp = vp; 661 a.a_vap = vap; 662 a.a_cred = cred; 663 error = vop_pre(vp, &mp, &mpsafe, FST_NO); 664 if (error) 665 return error; 666 error = (VCALL(vp, VOFFSET(vop_getattr), &a)); 667 vop_post(vp, mp, mpsafe, FST_NO); 668 return error; 669 } 670 671 const int vop_setattr_vp_offsets[] = { 672 VOPARG_OFFSETOF(struct vop_setattr_args,a_vp), 673 VDESC_NO_OFFSET 674 }; 675 const struct vnodeop_desc vop_setattr_desc = { 676 VOP_SETATTR_DESCOFFSET, 677 "vop_setattr", 678 0, 679 vop_setattr_vp_offsets, 680 VDESC_NO_OFFSET, 681 VOPARG_OFFSETOF(struct vop_setattr_args, a_cred), 682 VDESC_NO_OFFSET, 683 }; 684 int 685 VOP_SETATTR(struct vnode *vp, 686 struct vattr *vap, 687 kauth_cred_t cred) 688 { 689 int error; 690 bool mpsafe; 691 struct vop_setattr_args a; 692 struct mount *mp; 693 a.a_desc = VDESC(vop_setattr); 694 a.a_vp = vp; 695 a.a_vap = vap; 696 a.a_cred = cred; 697 vop_setattr_pre(&a); 698 error = vop_pre(vp, &mp, &mpsafe, FST_NO); 699 if (error) 700 return error; 701 error = (VCALL(vp, VOFFSET(vop_setattr), &a)); 702 vop_post(vp, mp, mpsafe, FST_NO); 703 vop_setattr_post(&a, error); 704 return error; 705 } 706 707 const int vop_read_vp_offsets[] = { 708 VOPARG_OFFSETOF(struct vop_read_args,a_vp), 709 VDESC_NO_OFFSET 710 }; 711 const struct vnodeop_desc vop_read_desc = { 712 VOP_READ_DESCOFFSET, 713 "vop_read", 714 0, 715 vop_read_vp_offsets, 716 VDESC_NO_OFFSET, 717 VOPARG_OFFSETOF(struct vop_read_args, a_cred), 718 VDESC_NO_OFFSET, 719 }; 720 int 721 VOP_READ(struct vnode *vp, 722 struct uio *uio, 723 int ioflag, 724 kauth_cred_t cred) 725 { 726 int error; 727 bool mpsafe; 728 struct vop_read_args a; 729 struct mount *mp; 730 a.a_desc = VDESC(vop_read); 731 a.a_vp = vp; 732 a.a_uio = uio; 733 a.a_ioflag = ioflag; 734 a.a_cred = cred; 735 error = vop_pre(vp, &mp, &mpsafe, FST_NO); 736 if (error) 737 return error; 738 error = (VCALL(vp, VOFFSET(vop_read), &a)); 739 vop_post(vp, mp, mpsafe, FST_NO); 740 vop_read_post(&a, error); 741 return error; 742 } 743 744 const int vop_write_vp_offsets[] = { 745 VOPARG_OFFSETOF(struct vop_write_args,a_vp), 746 VDESC_NO_OFFSET 747 }; 748 const struct vnodeop_desc vop_write_desc = { 749 VOP_WRITE_DESCOFFSET, 750 "vop_write", 751 0, 752 vop_write_vp_offsets, 753 VDESC_NO_OFFSET, 754 VOPARG_OFFSETOF(struct vop_write_args, a_cred), 755 VDESC_NO_OFFSET, 756 }; 757 int 758 VOP_WRITE(struct vnode *vp, 759 struct uio *uio, 760 int ioflag, 761 kauth_cred_t cred) 762 { 763 int error; 764 bool mpsafe; 765 struct vop_write_args a; 766 struct mount *mp; 767 a.a_desc = VDESC(vop_write); 768 a.a_vp = vp; 769 a.a_uio = uio; 770 a.a_ioflag = ioflag; 771 a.a_cred = cred; 772 vop_write_pre(&a); 773 error = vop_pre(vp, &mp, &mpsafe, FST_NO); 774 if (error) 775 return error; 776 error = (VCALL(vp, VOFFSET(vop_write), &a)); 777 vop_post(vp, mp, mpsafe, FST_NO); 778 vop_write_post(&a, error); 779 return error; 780 } 781 782 const int vop_fallocate_vp_offsets[] = { 783 VOPARG_OFFSETOF(struct vop_fallocate_args,a_vp), 784 VDESC_NO_OFFSET 785 }; 786 const struct vnodeop_desc vop_fallocate_desc = { 787 VOP_FALLOCATE_DESCOFFSET, 788 "vop_fallocate", 789 0, 790 vop_fallocate_vp_offsets, 791 VDESC_NO_OFFSET, 792 VDESC_NO_OFFSET, 793 VDESC_NO_OFFSET, 794 }; 795 int 796 VOP_FALLOCATE(struct vnode *vp, 797 off_t pos, 798 off_t len) 799 { 800 int error; 801 bool mpsafe; 802 struct vop_fallocate_args a; 803 struct mount *mp; 804 a.a_desc = VDESC(vop_fallocate); 805 a.a_vp = vp; 806 a.a_pos = pos; 807 a.a_len = len; 808 error = vop_pre(vp, &mp, &mpsafe, FST_NO); 809 if (error) 810 return error; 811 error = (VCALL(vp, VOFFSET(vop_fallocate), &a)); 812 vop_post(vp, mp, mpsafe, FST_NO); 813 return error; 814 } 815 816 const int vop_fdiscard_vp_offsets[] = { 817 VOPARG_OFFSETOF(struct vop_fdiscard_args,a_vp), 818 VDESC_NO_OFFSET 819 }; 820 const struct vnodeop_desc vop_fdiscard_desc = { 821 VOP_FDISCARD_DESCOFFSET, 822 "vop_fdiscard", 823 0, 824 vop_fdiscard_vp_offsets, 825 VDESC_NO_OFFSET, 826 VDESC_NO_OFFSET, 827 VDESC_NO_OFFSET, 828 }; 829 int 830 VOP_FDISCARD(struct vnode *vp, 831 off_t pos, 832 off_t len) 833 { 834 int error; 835 bool mpsafe; 836 struct vop_fdiscard_args a; 837 struct mount *mp; 838 a.a_desc = VDESC(vop_fdiscard); 839 a.a_vp = vp; 840 a.a_pos = pos; 841 a.a_len = len; 842 error = vop_pre(vp, &mp, &mpsafe, FST_NO); 843 if (error) 844 return error; 845 error = (VCALL(vp, VOFFSET(vop_fdiscard), &a)); 846 vop_post(vp, mp, mpsafe, FST_NO); 847 return error; 848 } 849 850 const int vop_ioctl_vp_offsets[] = { 851 VOPARG_OFFSETOF(struct vop_ioctl_args,a_vp), 852 VDESC_NO_OFFSET 853 }; 854 const struct vnodeop_desc vop_ioctl_desc = { 855 VOP_IOCTL_DESCOFFSET, 856 "vop_ioctl", 857 0, 858 vop_ioctl_vp_offsets, 859 VDESC_NO_OFFSET, 860 VOPARG_OFFSETOF(struct vop_ioctl_args, a_cred), 861 VDESC_NO_OFFSET, 862 }; 863 int 864 VOP_IOCTL(struct vnode *vp, 865 u_long command, 866 void *data, 867 int fflag, 868 kauth_cred_t cred) 869 { 870 int error; 871 bool mpsafe; 872 struct vop_ioctl_args a; 873 struct mount *mp; 874 a.a_desc = VDESC(vop_ioctl); 875 a.a_vp = vp; 876 a.a_command = command; 877 a.a_data = data; 878 a.a_fflag = fflag; 879 a.a_cred = cred; 880 error = vop_pre(vp, &mp, &mpsafe, FST_NO); 881 if (error) 882 return error; 883 error = (VCALL(vp, VOFFSET(vop_ioctl), &a)); 884 vop_post(vp, mp, mpsafe, FST_NO); 885 return error; 886 } 887 888 const int vop_fcntl_vp_offsets[] = { 889 VOPARG_OFFSETOF(struct vop_fcntl_args,a_vp), 890 VDESC_NO_OFFSET 891 }; 892 const struct vnodeop_desc vop_fcntl_desc = { 893 VOP_FCNTL_DESCOFFSET, 894 "vop_fcntl", 895 0, 896 vop_fcntl_vp_offsets, 897 VDESC_NO_OFFSET, 898 VOPARG_OFFSETOF(struct vop_fcntl_args, a_cred), 899 VDESC_NO_OFFSET, 900 }; 901 int 902 VOP_FCNTL(struct vnode *vp, 903 u_int command, 904 void *data, 905 int fflag, 906 kauth_cred_t cred) 907 { 908 int error; 909 bool mpsafe; 910 struct vop_fcntl_args a; 911 struct mount *mp; 912 a.a_desc = VDESC(vop_fcntl); 913 a.a_vp = vp; 914 a.a_command = command; 915 a.a_data = data; 916 a.a_fflag = fflag; 917 a.a_cred = cred; 918 error = vop_pre(vp, &mp, &mpsafe, FST_NO); 919 if (error) 920 return error; 921 error = (VCALL(vp, VOFFSET(vop_fcntl), &a)); 922 vop_post(vp, mp, mpsafe, FST_NO); 923 return error; 924 } 925 926 const int vop_poll_vp_offsets[] = { 927 VOPARG_OFFSETOF(struct vop_poll_args,a_vp), 928 VDESC_NO_OFFSET 929 }; 930 const struct vnodeop_desc vop_poll_desc = { 931 VOP_POLL_DESCOFFSET, 932 "vop_poll", 933 0, 934 vop_poll_vp_offsets, 935 VDESC_NO_OFFSET, 936 VDESC_NO_OFFSET, 937 VDESC_NO_OFFSET, 938 }; 939 int 940 VOP_POLL(struct vnode *vp, 941 int events) 942 { 943 int error; 944 bool mpsafe; 945 struct vop_poll_args a; 946 struct mount *mp; 947 a.a_desc = VDESC(vop_poll); 948 a.a_vp = vp; 949 a.a_events = events; 950 error = vop_pre(vp, &mp, &mpsafe, FST_YES); 951 if (error) 952 return error; 953 error = (VCALL(vp, VOFFSET(vop_poll), &a)); 954 vop_post(vp, mp, mpsafe, FST_YES); 955 return error; 956 } 957 958 const int vop_kqfilter_vp_offsets[] = { 959 VOPARG_OFFSETOF(struct vop_kqfilter_args,a_vp), 960 VDESC_NO_OFFSET 961 }; 962 const struct vnodeop_desc vop_kqfilter_desc = { 963 VOP_KQFILTER_DESCOFFSET, 964 "vop_kqfilter", 965 0, 966 vop_kqfilter_vp_offsets, 967 VDESC_NO_OFFSET, 968 VDESC_NO_OFFSET, 969 VDESC_NO_OFFSET, 970 }; 971 int 972 VOP_KQFILTER(struct vnode *vp, 973 struct knote *kn) 974 { 975 int error; 976 bool mpsafe; 977 struct vop_kqfilter_args a; 978 struct mount *mp; 979 a.a_desc = VDESC(vop_kqfilter); 980 a.a_vp = vp; 981 a.a_kn = kn; 982 error = vop_pre(vp, &mp, &mpsafe, FST_YES); 983 if (error) 984 return error; 985 error = (VCALL(vp, VOFFSET(vop_kqfilter), &a)); 986 vop_post(vp, mp, mpsafe, FST_YES); 987 return error; 988 } 989 990 const int vop_revoke_vp_offsets[] = { 991 VOPARG_OFFSETOF(struct vop_revoke_args,a_vp), 992 VDESC_NO_OFFSET 993 }; 994 const struct vnodeop_desc vop_revoke_desc = { 995 VOP_REVOKE_DESCOFFSET, 996 "vop_revoke", 997 0, 998 vop_revoke_vp_offsets, 999 VDESC_NO_OFFSET, 1000 VDESC_NO_OFFSET, 1001 VDESC_NO_OFFSET, 1002 }; 1003 int 1004 VOP_REVOKE(struct vnode *vp, 1005 int flags) 1006 { 1007 int error; 1008 bool mpsafe; 1009 struct vop_revoke_args a; 1010 struct mount *mp; 1011 a.a_desc = VDESC(vop_revoke); 1012 a.a_vp = vp; 1013 a.a_flags = flags; 1014 error = vop_pre(vp, &mp, &mpsafe, FST_NO); 1015 if (error) 1016 return error; 1017 error = (VCALL(vp, VOFFSET(vop_revoke), &a)); 1018 vop_post(vp, mp, mpsafe, FST_NO); 1019 return error; 1020 } 1021 1022 const int vop_mmap_vp_offsets[] = { 1023 VOPARG_OFFSETOF(struct vop_mmap_args,a_vp), 1024 VDESC_NO_OFFSET 1025 }; 1026 const struct vnodeop_desc vop_mmap_desc = { 1027 VOP_MMAP_DESCOFFSET, 1028 "vop_mmap", 1029 0, 1030 vop_mmap_vp_offsets, 1031 VDESC_NO_OFFSET, 1032 VOPARG_OFFSETOF(struct vop_mmap_args, a_cred), 1033 VDESC_NO_OFFSET, 1034 }; 1035 int 1036 VOP_MMAP(struct vnode *vp, 1037 vm_prot_t prot, 1038 kauth_cred_t cred) 1039 { 1040 int error; 1041 bool mpsafe; 1042 struct vop_mmap_args a; 1043 struct mount *mp; 1044 a.a_desc = VDESC(vop_mmap); 1045 a.a_vp = vp; 1046 a.a_prot = prot; 1047 a.a_cred = cred; 1048 error = vop_pre(vp, &mp, &mpsafe, FST_YES); 1049 if (error) 1050 return error; 1051 error = (VCALL(vp, VOFFSET(vop_mmap), &a)); 1052 vop_post(vp, mp, mpsafe, FST_YES); 1053 return error; 1054 } 1055 1056 const int vop_fsync_vp_offsets[] = { 1057 VOPARG_OFFSETOF(struct vop_fsync_args,a_vp), 1058 VDESC_NO_OFFSET 1059 }; 1060 const struct vnodeop_desc vop_fsync_desc = { 1061 VOP_FSYNC_DESCOFFSET, 1062 "vop_fsync", 1063 0, 1064 vop_fsync_vp_offsets, 1065 VDESC_NO_OFFSET, 1066 VOPARG_OFFSETOF(struct vop_fsync_args, a_cred), 1067 VDESC_NO_OFFSET, 1068 }; 1069 int 1070 VOP_FSYNC(struct vnode *vp, 1071 kauth_cred_t cred, 1072 int flags, 1073 off_t offlo, 1074 off_t offhi) 1075 { 1076 int error; 1077 bool mpsafe; 1078 struct vop_fsync_args a; 1079 struct mount *mp; 1080 a.a_desc = VDESC(vop_fsync); 1081 a.a_vp = vp; 1082 a.a_cred = cred; 1083 a.a_flags = flags; 1084 a.a_offlo = offlo; 1085 a.a_offhi = offhi; 1086 error = vop_pre(vp, &mp, &mpsafe, FST_NO); 1087 if (error) 1088 return error; 1089 error = (VCALL(vp, VOFFSET(vop_fsync), &a)); 1090 vop_post(vp, mp, mpsafe, FST_NO); 1091 return error; 1092 } 1093 1094 const int vop_seek_vp_offsets[] = { 1095 VOPARG_OFFSETOF(struct vop_seek_args,a_vp), 1096 VDESC_NO_OFFSET 1097 }; 1098 const struct vnodeop_desc vop_seek_desc = { 1099 VOP_SEEK_DESCOFFSET, 1100 "vop_seek", 1101 0, 1102 vop_seek_vp_offsets, 1103 VDESC_NO_OFFSET, 1104 VOPARG_OFFSETOF(struct vop_seek_args, a_cred), 1105 VDESC_NO_OFFSET, 1106 }; 1107 int 1108 VOP_SEEK(struct vnode *vp, 1109 off_t oldoff, 1110 off_t newoff, 1111 kauth_cred_t cred) 1112 { 1113 int error; 1114 bool mpsafe; 1115 struct vop_seek_args a; 1116 struct mount *mp; 1117 a.a_desc = VDESC(vop_seek); 1118 a.a_vp = vp; 1119 a.a_oldoff = oldoff; 1120 a.a_newoff = newoff; 1121 a.a_cred = cred; 1122 error = vop_pre(vp, &mp, &mpsafe, FST_YES); 1123 if (error) 1124 return error; 1125 error = (VCALL(vp, VOFFSET(vop_seek), &a)); 1126 vop_post(vp, mp, mpsafe, FST_YES); 1127 return error; 1128 } 1129 1130 const int vop_remove_vp_offsets[] = { 1131 VOPARG_OFFSETOF(struct vop_remove_v3_args,a_dvp), 1132 VOPARG_OFFSETOF(struct vop_remove_v3_args,a_vp), 1133 VDESC_NO_OFFSET 1134 }; 1135 const struct vnodeop_desc vop_remove_desc = { 1136 VOP_REMOVE_DESCOFFSET, 1137 "vop_remove", 1138 0 | VDESC_VP1_WILLPUT, 1139 vop_remove_vp_offsets, 1140 VDESC_NO_OFFSET, 1141 VDESC_NO_OFFSET, 1142 VOPARG_OFFSETOF(struct vop_remove_v3_args, a_cnp), 1143 }; 1144 int 1145 VOP_REMOVE(struct vnode *dvp, 1146 struct vnode *vp, 1147 struct componentname *cnp) 1148 { 1149 int error; 1150 bool mpsafe; 1151 struct vop_remove_v3_args a; 1152 struct mount *mp; 1153 a.a_desc = VDESC(vop_remove); 1154 a.a_dvp = dvp; 1155 a.a_vp = vp; 1156 a.a_cnp = cnp; 1157 vop_remove_pre(&a); 1158 error = vop_pre(dvp, &mp, &mpsafe, FST_NO); 1159 if (error) 1160 return error; 1161 error = (VCALL(dvp, VOFFSET(vop_remove), &a)); 1162 vop_post(dvp, mp, mpsafe, FST_NO); 1163 vop_remove_post(&a, error); 1164 return error; 1165 } 1166 1167 const int vop_link_vp_offsets[] = { 1168 VOPARG_OFFSETOF(struct vop_link_v2_args,a_dvp), 1169 VOPARG_OFFSETOF(struct vop_link_v2_args,a_vp), 1170 VDESC_NO_OFFSET 1171 }; 1172 const struct vnodeop_desc vop_link_desc = { 1173 VOP_LINK_DESCOFFSET, 1174 "vop_link", 1175 0, 1176 vop_link_vp_offsets, 1177 VDESC_NO_OFFSET, 1178 VDESC_NO_OFFSET, 1179 VOPARG_OFFSETOF(struct vop_link_v2_args, a_cnp), 1180 }; 1181 int 1182 VOP_LINK(struct vnode *dvp, 1183 struct vnode *vp, 1184 struct componentname *cnp) 1185 { 1186 int error; 1187 bool mpsafe; 1188 struct vop_link_v2_args a; 1189 struct mount *mp; 1190 a.a_desc = VDESC(vop_link); 1191 a.a_dvp = dvp; 1192 a.a_vp = vp; 1193 a.a_cnp = cnp; 1194 error = vop_pre(dvp, &mp, &mpsafe, FST_NO); 1195 if (error) 1196 return error; 1197 error = (VCALL(dvp, VOFFSET(vop_link), &a)); 1198 vop_post(dvp, mp, mpsafe, FST_NO); 1199 vop_link_post(&a, error); 1200 return error; 1201 } 1202 1203 const int vop_rename_vp_offsets[] = { 1204 VOPARG_OFFSETOF(struct vop_rename_args,a_fdvp), 1205 VOPARG_OFFSETOF(struct vop_rename_args,a_fvp), 1206 VOPARG_OFFSETOF(struct vop_rename_args,a_tdvp), 1207 VOPARG_OFFSETOF(struct vop_rename_args,a_tvp), 1208 VDESC_NO_OFFSET 1209 }; 1210 const struct vnodeop_desc vop_rename_desc = { 1211 VOP_RENAME_DESCOFFSET, 1212 "vop_rename", 1213 0 | VDESC_VP0_WILLRELE | VDESC_VP1_WILLRELE | VDESC_VP2_WILLPUT | VDESC_VP3_WILLPUT, 1214 vop_rename_vp_offsets, 1215 VDESC_NO_OFFSET, 1216 VDESC_NO_OFFSET, 1217 VOPARG_OFFSETOF(struct vop_rename_args, a_fcnp), 1218 }; 1219 int 1220 VOP_RENAME(struct vnode *fdvp, 1221 struct vnode *fvp, 1222 struct componentname *fcnp, 1223 struct vnode *tdvp, 1224 struct vnode *tvp, 1225 struct componentname *tcnp) 1226 { 1227 int error; 1228 bool mpsafe; 1229 struct vop_rename_args a; 1230 struct mount *mp; 1231 a.a_desc = VDESC(vop_rename); 1232 a.a_fdvp = fdvp; 1233 a.a_fvp = fvp; 1234 a.a_fcnp = fcnp; 1235 a.a_tdvp = tdvp; 1236 a.a_tvp = tvp; 1237 a.a_tcnp = tcnp; 1238 error = vop_pre(fdvp, &mp, &mpsafe, FST_YES); 1239 if (error) 1240 return error; 1241 error = (VCALL(fdvp, VOFFSET(vop_rename), &a)); 1242 vop_post(fdvp, mp, mpsafe, FST_YES); 1243 return error; 1244 } 1245 1246 const int vop_mkdir_vp_offsets[] = { 1247 VOPARG_OFFSETOF(struct vop_mkdir_v3_args,a_dvp), 1248 VDESC_NO_OFFSET 1249 }; 1250 const struct vnodeop_desc vop_mkdir_desc = { 1251 VOP_MKDIR_DESCOFFSET, 1252 "vop_mkdir", 1253 0, 1254 vop_mkdir_vp_offsets, 1255 VOPARG_OFFSETOF(struct vop_mkdir_v3_args, a_vpp), 1256 VDESC_NO_OFFSET, 1257 VOPARG_OFFSETOF(struct vop_mkdir_v3_args, a_cnp), 1258 }; 1259 int 1260 VOP_MKDIR(struct vnode *dvp, 1261 struct vnode **vpp, 1262 struct componentname *cnp, 1263 struct vattr *vap) 1264 { 1265 int error; 1266 bool mpsafe; 1267 struct vop_mkdir_v3_args a; 1268 struct mount *mp; 1269 a.a_desc = VDESC(vop_mkdir); 1270 a.a_dvp = dvp; 1271 a.a_vpp = vpp; 1272 a.a_cnp = cnp; 1273 a.a_vap = vap; 1274 error = vop_pre(dvp, &mp, &mpsafe, FST_NO); 1275 if (error) 1276 return error; 1277 error = (VCALL(dvp, VOFFSET(vop_mkdir), &a)); 1278 vop_post(dvp, mp, mpsafe, FST_NO); 1279 vop_mkdir_post(&a, error); 1280 #ifdef DIAGNOSTIC 1281 if (error == 0) 1282 KASSERT((*vpp)->v_size != VSIZENOTSET 1283 && (*vpp)->v_writesize != VSIZENOTSET); 1284 #endif /* DIAGNOSTIC */ 1285 return error; 1286 } 1287 1288 const int vop_rmdir_vp_offsets[] = { 1289 VOPARG_OFFSETOF(struct vop_rmdir_v2_args,a_dvp), 1290 VOPARG_OFFSETOF(struct vop_rmdir_v2_args,a_vp), 1291 VDESC_NO_OFFSET 1292 }; 1293 const struct vnodeop_desc vop_rmdir_desc = { 1294 VOP_RMDIR_DESCOFFSET, 1295 "vop_rmdir", 1296 0 | VDESC_VP1_WILLPUT, 1297 vop_rmdir_vp_offsets, 1298 VDESC_NO_OFFSET, 1299 VDESC_NO_OFFSET, 1300 VOPARG_OFFSETOF(struct vop_rmdir_v2_args, a_cnp), 1301 }; 1302 int 1303 VOP_RMDIR(struct vnode *dvp, 1304 struct vnode *vp, 1305 struct componentname *cnp) 1306 { 1307 int error; 1308 bool mpsafe; 1309 struct vop_rmdir_v2_args a; 1310 struct mount *mp; 1311 a.a_desc = VDESC(vop_rmdir); 1312 a.a_dvp = dvp; 1313 a.a_vp = vp; 1314 a.a_cnp = cnp; 1315 vop_rmdir_pre(&a); 1316 error = vop_pre(dvp, &mp, &mpsafe, FST_NO); 1317 if (error) 1318 return error; 1319 error = (VCALL(dvp, VOFFSET(vop_rmdir), &a)); 1320 vop_post(dvp, mp, mpsafe, FST_NO); 1321 vop_rmdir_post(&a, error); 1322 return error; 1323 } 1324 1325 const int vop_symlink_vp_offsets[] = { 1326 VOPARG_OFFSETOF(struct vop_symlink_v3_args,a_dvp), 1327 VDESC_NO_OFFSET 1328 }; 1329 const struct vnodeop_desc vop_symlink_desc = { 1330 VOP_SYMLINK_DESCOFFSET, 1331 "vop_symlink", 1332 0, 1333 vop_symlink_vp_offsets, 1334 VOPARG_OFFSETOF(struct vop_symlink_v3_args, a_vpp), 1335 VDESC_NO_OFFSET, 1336 VOPARG_OFFSETOF(struct vop_symlink_v3_args, a_cnp), 1337 }; 1338 int 1339 VOP_SYMLINK(struct vnode *dvp, 1340 struct vnode **vpp, 1341 struct componentname *cnp, 1342 struct vattr *vap, 1343 char *target) 1344 { 1345 int error; 1346 bool mpsafe; 1347 struct vop_symlink_v3_args a; 1348 struct mount *mp; 1349 a.a_desc = VDESC(vop_symlink); 1350 a.a_dvp = dvp; 1351 a.a_vpp = vpp; 1352 a.a_cnp = cnp; 1353 a.a_vap = vap; 1354 a.a_target = target; 1355 error = vop_pre(dvp, &mp, &mpsafe, FST_NO); 1356 if (error) 1357 return error; 1358 error = (VCALL(dvp, VOFFSET(vop_symlink), &a)); 1359 vop_post(dvp, mp, mpsafe, FST_NO); 1360 vop_symlink_post(&a, error); 1361 #ifdef DIAGNOSTIC 1362 if (error == 0) 1363 KASSERT((*vpp)->v_size != VSIZENOTSET 1364 && (*vpp)->v_writesize != VSIZENOTSET); 1365 #endif /* DIAGNOSTIC */ 1366 return error; 1367 } 1368 1369 const int vop_readdir_vp_offsets[] = { 1370 VOPARG_OFFSETOF(struct vop_readdir_args,a_vp), 1371 VDESC_NO_OFFSET 1372 }; 1373 const struct vnodeop_desc vop_readdir_desc = { 1374 VOP_READDIR_DESCOFFSET, 1375 "vop_readdir", 1376 0, 1377 vop_readdir_vp_offsets, 1378 VDESC_NO_OFFSET, 1379 VOPARG_OFFSETOF(struct vop_readdir_args, a_cred), 1380 VDESC_NO_OFFSET, 1381 }; 1382 int 1383 VOP_READDIR(struct vnode *vp, 1384 struct uio *uio, 1385 kauth_cred_t cred, 1386 int *eofflag, 1387 off_t **cookies, 1388 int *ncookies) 1389 { 1390 int error; 1391 bool mpsafe; 1392 struct vop_readdir_args a; 1393 struct mount *mp; 1394 a.a_desc = VDESC(vop_readdir); 1395 a.a_vp = vp; 1396 a.a_uio = uio; 1397 a.a_cred = cred; 1398 a.a_eofflag = eofflag; 1399 a.a_cookies = cookies; 1400 a.a_ncookies = ncookies; 1401 error = vop_pre(vp, &mp, &mpsafe, FST_NO); 1402 if (error) 1403 return error; 1404 error = (VCALL(vp, VOFFSET(vop_readdir), &a)); 1405 vop_post(vp, mp, mpsafe, FST_NO); 1406 return error; 1407 } 1408 1409 const int vop_readlink_vp_offsets[] = { 1410 VOPARG_OFFSETOF(struct vop_readlink_args,a_vp), 1411 VDESC_NO_OFFSET 1412 }; 1413 const struct vnodeop_desc vop_readlink_desc = { 1414 VOP_READLINK_DESCOFFSET, 1415 "vop_readlink", 1416 0, 1417 vop_readlink_vp_offsets, 1418 VDESC_NO_OFFSET, 1419 VOPARG_OFFSETOF(struct vop_readlink_args, a_cred), 1420 VDESC_NO_OFFSET, 1421 }; 1422 int 1423 VOP_READLINK(struct vnode *vp, 1424 struct uio *uio, 1425 kauth_cred_t cred) 1426 { 1427 int error; 1428 bool mpsafe; 1429 struct vop_readlink_args a; 1430 struct mount *mp; 1431 a.a_desc = VDESC(vop_readlink); 1432 a.a_vp = vp; 1433 a.a_uio = uio; 1434 a.a_cred = cred; 1435 error = vop_pre(vp, &mp, &mpsafe, FST_NO); 1436 if (error) 1437 return error; 1438 error = (VCALL(vp, VOFFSET(vop_readlink), &a)); 1439 vop_post(vp, mp, mpsafe, FST_NO); 1440 return error; 1441 } 1442 1443 const int vop_abortop_vp_offsets[] = { 1444 VOPARG_OFFSETOF(struct vop_abortop_args,a_dvp), 1445 VDESC_NO_OFFSET 1446 }; 1447 const struct vnodeop_desc vop_abortop_desc = { 1448 VOP_ABORTOP_DESCOFFSET, 1449 "vop_abortop", 1450 0, 1451 vop_abortop_vp_offsets, 1452 VDESC_NO_OFFSET, 1453 VDESC_NO_OFFSET, 1454 VOPARG_OFFSETOF(struct vop_abortop_args, a_cnp), 1455 }; 1456 int 1457 VOP_ABORTOP(struct vnode *dvp, 1458 struct componentname *cnp) 1459 { 1460 int error; 1461 bool mpsafe; 1462 struct vop_abortop_args a; 1463 struct mount *mp; 1464 a.a_desc = VDESC(vop_abortop); 1465 a.a_dvp = dvp; 1466 a.a_cnp = cnp; 1467 error = vop_pre(dvp, &mp, &mpsafe, FST_YES); 1468 if (error) 1469 return error; 1470 error = (VCALL(dvp, VOFFSET(vop_abortop), &a)); 1471 vop_post(dvp, mp, mpsafe, FST_YES); 1472 return error; 1473 } 1474 1475 const int vop_inactive_vp_offsets[] = { 1476 VOPARG_OFFSETOF(struct vop_inactive_v2_args,a_vp), 1477 VDESC_NO_OFFSET 1478 }; 1479 const struct vnodeop_desc vop_inactive_desc = { 1480 VOP_INACTIVE_DESCOFFSET, 1481 "vop_inactive", 1482 0, 1483 vop_inactive_vp_offsets, 1484 VDESC_NO_OFFSET, 1485 VDESC_NO_OFFSET, 1486 VDESC_NO_OFFSET, 1487 }; 1488 int 1489 VOP_INACTIVE(struct vnode *vp, 1490 bool *recycle) 1491 { 1492 int error; 1493 bool mpsafe; 1494 struct vop_inactive_v2_args a; 1495 struct mount *mp; 1496 a.a_desc = VDESC(vop_inactive); 1497 a.a_vp = vp; 1498 a.a_recycle = recycle; 1499 error = vop_pre(vp, &mp, &mpsafe, FST_NO); 1500 if (error) 1501 return error; 1502 error = (VCALL(vp, VOFFSET(vop_inactive), &a)); 1503 vop_post(vp, mp, mpsafe, FST_NO); 1504 return error; 1505 } 1506 1507 const int vop_reclaim_vp_offsets[] = { 1508 VOPARG_OFFSETOF(struct vop_reclaim_v2_args,a_vp), 1509 VDESC_NO_OFFSET 1510 }; 1511 const struct vnodeop_desc vop_reclaim_desc = { 1512 VOP_RECLAIM_DESCOFFSET, 1513 "vop_reclaim", 1514 0, 1515 vop_reclaim_vp_offsets, 1516 VDESC_NO_OFFSET, 1517 VDESC_NO_OFFSET, 1518 VDESC_NO_OFFSET, 1519 }; 1520 int 1521 VOP_RECLAIM(struct vnode *vp) 1522 { 1523 int error; 1524 bool mpsafe; 1525 struct vop_reclaim_v2_args a; 1526 struct mount *mp; 1527 a.a_desc = VDESC(vop_reclaim); 1528 a.a_vp = vp; 1529 error = vop_pre(vp, &mp, &mpsafe, FST_NO); 1530 if (error) 1531 return error; 1532 error = (VCALL(vp, VOFFSET(vop_reclaim), &a)); 1533 vop_post(vp, mp, mpsafe, FST_NO); 1534 return error; 1535 } 1536 1537 const int vop_lock_vp_offsets[] = { 1538 VOPARG_OFFSETOF(struct vop_lock_args,a_vp), 1539 VDESC_NO_OFFSET 1540 }; 1541 const struct vnodeop_desc vop_lock_desc = { 1542 VOP_LOCK_DESCOFFSET, 1543 "vop_lock", 1544 0, 1545 vop_lock_vp_offsets, 1546 VDESC_NO_OFFSET, 1547 VDESC_NO_OFFSET, 1548 VDESC_NO_OFFSET, 1549 }; 1550 int 1551 VOP_LOCK(struct vnode *vp, 1552 int flags) 1553 { 1554 int error; 1555 bool mpsafe; 1556 struct vop_lock_args a; 1557 struct mount *mp; 1558 a.a_desc = VDESC(vop_lock); 1559 a.a_vp = vp; 1560 a.a_flags = flags; 1561 error = vop_pre(vp, &mp, &mpsafe, (!(flags & (LK_SHARED|LK_EXCLUSIVE)) ? FST_NO : (flags & LK_NOWAIT ? FST_TRY : FST_YES))); 1562 if (error) 1563 return error; 1564 error = (VCALL(vp, VOFFSET(vop_lock), &a)); 1565 vop_post(vp, mp, mpsafe, (flags & (LK_UPGRADE|LK_DOWNGRADE) ? FST_NO : (error ? FST_YES : FST_NO))); 1566 return error; 1567 } 1568 1569 const int vop_unlock_vp_offsets[] = { 1570 VOPARG_OFFSETOF(struct vop_unlock_args,a_vp), 1571 VDESC_NO_OFFSET 1572 }; 1573 const struct vnodeop_desc vop_unlock_desc = { 1574 VOP_UNLOCK_DESCOFFSET, 1575 "vop_unlock", 1576 0, 1577 vop_unlock_vp_offsets, 1578 VDESC_NO_OFFSET, 1579 VDESC_NO_OFFSET, 1580 VDESC_NO_OFFSET, 1581 }; 1582 int 1583 VOP_UNLOCK(struct vnode *vp) 1584 { 1585 int error; 1586 bool mpsafe; 1587 struct vop_unlock_args a; 1588 struct mount *mp; 1589 a.a_desc = VDESC(vop_unlock); 1590 a.a_vp = vp; 1591 error = vop_pre(vp, &mp, &mpsafe, FST_NO); 1592 if (error) 1593 return error; 1594 error = (VCALL(vp, VOFFSET(vop_unlock), &a)); 1595 vop_post(vp, mp, mpsafe, FST_YES); 1596 return error; 1597 } 1598 1599 const int vop_bmap_vp_offsets[] = { 1600 VOPARG_OFFSETOF(struct vop_bmap_args,a_vp), 1601 VDESC_NO_OFFSET 1602 }; 1603 const struct vnodeop_desc vop_bmap_desc = { 1604 VOP_BMAP_DESCOFFSET, 1605 "vop_bmap", 1606 0, 1607 vop_bmap_vp_offsets, 1608 VOPARG_OFFSETOF(struct vop_bmap_args, a_vpp), 1609 VDESC_NO_OFFSET, 1610 VDESC_NO_OFFSET, 1611 }; 1612 int 1613 VOP_BMAP(struct vnode *vp, 1614 daddr_t bn, 1615 struct vnode **vpp, 1616 daddr_t *bnp, 1617 int *runp) 1618 { 1619 int error; 1620 bool mpsafe; 1621 struct vop_bmap_args a; 1622 struct mount *mp; 1623 a.a_desc = VDESC(vop_bmap); 1624 a.a_vp = vp; 1625 a.a_bn = bn; 1626 a.a_vpp = vpp; 1627 a.a_bnp = bnp; 1628 a.a_runp = runp; 1629 error = vop_pre(vp, &mp, &mpsafe, FST_YES); 1630 if (error) 1631 return error; 1632 error = (VCALL(vp, VOFFSET(vop_bmap), &a)); 1633 vop_post(vp, mp, mpsafe, FST_YES); 1634 return error; 1635 } 1636 1637 const int vop_strategy_vp_offsets[] = { 1638 VOPARG_OFFSETOF(struct vop_strategy_args,a_vp), 1639 VDESC_NO_OFFSET 1640 }; 1641 const struct vnodeop_desc vop_strategy_desc = { 1642 VOP_STRATEGY_DESCOFFSET, 1643 "vop_strategy", 1644 0, 1645 vop_strategy_vp_offsets, 1646 VDESC_NO_OFFSET, 1647 VDESC_NO_OFFSET, 1648 VDESC_NO_OFFSET, 1649 }; 1650 int 1651 VOP_STRATEGY(struct vnode *vp, 1652 struct buf *bp) 1653 { 1654 int error; 1655 bool mpsafe; 1656 struct vop_strategy_args a; 1657 struct mount *mp; 1658 a.a_desc = VDESC(vop_strategy); 1659 a.a_vp = vp; 1660 a.a_bp = bp; 1661 error = vop_pre(vp, &mp, &mpsafe, FST_NO); 1662 if (error) 1663 return error; 1664 error = (VCALL(vp, VOFFSET(vop_strategy), &a)); 1665 vop_post(vp, mp, mpsafe, FST_NO); 1666 return error; 1667 } 1668 1669 const int vop_print_vp_offsets[] = { 1670 VOPARG_OFFSETOF(struct vop_print_args,a_vp), 1671 VDESC_NO_OFFSET 1672 }; 1673 const struct vnodeop_desc vop_print_desc = { 1674 VOP_PRINT_DESCOFFSET, 1675 "vop_print", 1676 0, 1677 vop_print_vp_offsets, 1678 VDESC_NO_OFFSET, 1679 VDESC_NO_OFFSET, 1680 VDESC_NO_OFFSET, 1681 }; 1682 int 1683 VOP_PRINT(struct vnode *vp) 1684 { 1685 int error; 1686 bool mpsafe; 1687 struct vop_print_args a; 1688 struct mount *mp; 1689 a.a_desc = VDESC(vop_print); 1690 a.a_vp = vp; 1691 error = vop_pre(vp, &mp, &mpsafe, FST_YES); 1692 if (error) 1693 return error; 1694 error = (VCALL(vp, VOFFSET(vop_print), &a)); 1695 vop_post(vp, mp, mpsafe, FST_YES); 1696 return error; 1697 } 1698 1699 const int vop_islocked_vp_offsets[] = { 1700 VOPARG_OFFSETOF(struct vop_islocked_args,a_vp), 1701 VDESC_NO_OFFSET 1702 }; 1703 const struct vnodeop_desc vop_islocked_desc = { 1704 VOP_ISLOCKED_DESCOFFSET, 1705 "vop_islocked", 1706 0, 1707 vop_islocked_vp_offsets, 1708 VDESC_NO_OFFSET, 1709 VDESC_NO_OFFSET, 1710 VDESC_NO_OFFSET, 1711 }; 1712 int 1713 VOP_ISLOCKED(struct vnode *vp) 1714 { 1715 int error; 1716 bool mpsafe; 1717 struct vop_islocked_args a; 1718 struct mount *mp; 1719 a.a_desc = VDESC(vop_islocked); 1720 a.a_vp = vp; 1721 error = vop_pre(vp, &mp, &mpsafe, FST_NO); 1722 if (error) 1723 return error; 1724 error = (VCALL(vp, VOFFSET(vop_islocked), &a)); 1725 vop_post(vp, mp, mpsafe, FST_NO); 1726 return error; 1727 } 1728 1729 const int vop_pathconf_vp_offsets[] = { 1730 VOPARG_OFFSETOF(struct vop_pathconf_args,a_vp), 1731 VDESC_NO_OFFSET 1732 }; 1733 const struct vnodeop_desc vop_pathconf_desc = { 1734 VOP_PATHCONF_DESCOFFSET, 1735 "vop_pathconf", 1736 0, 1737 vop_pathconf_vp_offsets, 1738 VDESC_NO_OFFSET, 1739 VDESC_NO_OFFSET, 1740 VDESC_NO_OFFSET, 1741 }; 1742 int 1743 VOP_PATHCONF(struct vnode *vp, 1744 int name, 1745 register_t *retval) 1746 { 1747 int error; 1748 bool mpsafe; 1749 struct vop_pathconf_args a; 1750 struct mount *mp; 1751 a.a_desc = VDESC(vop_pathconf); 1752 a.a_vp = vp; 1753 a.a_name = name; 1754 a.a_retval = retval; 1755 error = vop_pre(vp, &mp, &mpsafe, FST_NO); 1756 if (error) 1757 return error; 1758 error = (VCALL(vp, VOFFSET(vop_pathconf), &a)); 1759 vop_post(vp, mp, mpsafe, FST_NO); 1760 return error; 1761 } 1762 1763 const int vop_advlock_vp_offsets[] = { 1764 VOPARG_OFFSETOF(struct vop_advlock_args,a_vp), 1765 VDESC_NO_OFFSET 1766 }; 1767 const struct vnodeop_desc vop_advlock_desc = { 1768 VOP_ADVLOCK_DESCOFFSET, 1769 "vop_advlock", 1770 0, 1771 vop_advlock_vp_offsets, 1772 VDESC_NO_OFFSET, 1773 VDESC_NO_OFFSET, 1774 VDESC_NO_OFFSET, 1775 }; 1776 int 1777 VOP_ADVLOCK(struct vnode *vp, 1778 void *id, 1779 int op, 1780 struct flock *fl, 1781 int flags) 1782 { 1783 int error; 1784 bool mpsafe; 1785 struct vop_advlock_args a; 1786 struct mount *mp; 1787 a.a_desc = VDESC(vop_advlock); 1788 a.a_vp = vp; 1789 a.a_id = id; 1790 a.a_op = op; 1791 a.a_fl = fl; 1792 a.a_flags = flags; 1793 error = vop_pre(vp, &mp, &mpsafe, FST_NO); 1794 if (error) 1795 return error; 1796 error = (VCALL(vp, VOFFSET(vop_advlock), &a)); 1797 vop_post(vp, mp, mpsafe, FST_NO); 1798 return error; 1799 } 1800 1801 const int vop_whiteout_vp_offsets[] = { 1802 VOPARG_OFFSETOF(struct vop_whiteout_args,a_dvp), 1803 VDESC_NO_OFFSET 1804 }; 1805 const struct vnodeop_desc vop_whiteout_desc = { 1806 VOP_WHITEOUT_DESCOFFSET, 1807 "vop_whiteout", 1808 0, 1809 vop_whiteout_vp_offsets, 1810 VDESC_NO_OFFSET, 1811 VDESC_NO_OFFSET, 1812 VOPARG_OFFSETOF(struct vop_whiteout_args, a_cnp), 1813 }; 1814 int 1815 VOP_WHITEOUT(struct vnode *dvp, 1816 struct componentname *cnp, 1817 int flags) 1818 { 1819 int error; 1820 bool mpsafe; 1821 struct vop_whiteout_args a; 1822 struct mount *mp; 1823 a.a_desc = VDESC(vop_whiteout); 1824 a.a_dvp = dvp; 1825 a.a_cnp = cnp; 1826 a.a_flags = flags; 1827 error = vop_pre(dvp, &mp, &mpsafe, FST_NO); 1828 if (error) 1829 return error; 1830 error = (VCALL(dvp, VOFFSET(vop_whiteout), &a)); 1831 vop_post(dvp, mp, mpsafe, FST_NO); 1832 return error; 1833 } 1834 1835 const int vop_getpages_vp_offsets[] = { 1836 VOPARG_OFFSETOF(struct vop_getpages_args,a_vp), 1837 VDESC_NO_OFFSET 1838 }; 1839 const struct vnodeop_desc vop_getpages_desc = { 1840 VOP_GETPAGES_DESCOFFSET, 1841 "vop_getpages", 1842 0, 1843 vop_getpages_vp_offsets, 1844 VDESC_NO_OFFSET, 1845 VDESC_NO_OFFSET, 1846 VDESC_NO_OFFSET, 1847 }; 1848 int 1849 VOP_GETPAGES(struct vnode *vp, 1850 voff_t offset, 1851 struct vm_page **m, 1852 int *count, 1853 int centeridx, 1854 vm_prot_t access_type, 1855 int advice, 1856 int flags) 1857 { 1858 int error; 1859 bool mpsafe; 1860 struct vop_getpages_args a; 1861 struct mount *mp; 1862 a.a_desc = VDESC(vop_getpages); 1863 a.a_vp = vp; 1864 a.a_offset = offset; 1865 a.a_m = m; 1866 a.a_count = count; 1867 a.a_centeridx = centeridx; 1868 a.a_access_type = access_type; 1869 a.a_advice = advice; 1870 a.a_flags = flags; 1871 error = vop_pre(vp, &mp, &mpsafe, FST_NO); 1872 if (error) 1873 return error; 1874 error = (VCALL(vp, VOFFSET(vop_getpages), &a)); 1875 vop_post(vp, mp, mpsafe, FST_NO); 1876 return error; 1877 } 1878 1879 const int vop_putpages_vp_offsets[] = { 1880 VOPARG_OFFSETOF(struct vop_putpages_args,a_vp), 1881 VDESC_NO_OFFSET 1882 }; 1883 const struct vnodeop_desc vop_putpages_desc = { 1884 VOP_PUTPAGES_DESCOFFSET, 1885 "vop_putpages", 1886 0, 1887 vop_putpages_vp_offsets, 1888 VDESC_NO_OFFSET, 1889 VDESC_NO_OFFSET, 1890 VDESC_NO_OFFSET, 1891 }; 1892 int 1893 VOP_PUTPAGES(struct vnode *vp, 1894 voff_t offlo, 1895 voff_t offhi, 1896 int flags) 1897 { 1898 int error; 1899 bool mpsafe; 1900 struct vop_putpages_args a; 1901 struct mount *mp; 1902 a.a_desc = VDESC(vop_putpages); 1903 a.a_vp = vp; 1904 a.a_offlo = offlo; 1905 a.a_offhi = offhi; 1906 a.a_flags = flags; 1907 error = vop_pre(vp, &mp, &mpsafe, FST_NO); 1908 if (error) 1909 return error; 1910 error = (VCALL(vp, VOFFSET(vop_putpages), &a)); 1911 vop_post(vp, mp, mpsafe, FST_NO); 1912 return error; 1913 } 1914 1915 const int vop_getacl_vp_offsets[] = { 1916 VOPARG_OFFSETOF(struct vop_getacl_args,a_vp), 1917 VDESC_NO_OFFSET 1918 }; 1919 const struct vnodeop_desc vop_getacl_desc = { 1920 VOP_GETACL_DESCOFFSET, 1921 "vop_getacl", 1922 0, 1923 vop_getacl_vp_offsets, 1924 VDESC_NO_OFFSET, 1925 VOPARG_OFFSETOF(struct vop_getacl_args, a_cred), 1926 VDESC_NO_OFFSET, 1927 }; 1928 int 1929 VOP_GETACL(struct vnode *vp, 1930 acl_type_t type, 1931 struct acl *aclp, 1932 kauth_cred_t cred) 1933 { 1934 int error; 1935 bool mpsafe; 1936 struct vop_getacl_args a; 1937 struct mount *mp; 1938 a.a_desc = VDESC(vop_getacl); 1939 a.a_vp = vp; 1940 a.a_type = type; 1941 a.a_aclp = aclp; 1942 a.a_cred = cred; 1943 error = vop_pre(vp, &mp, &mpsafe, FST_YES); 1944 if (error) 1945 return error; 1946 error = (VCALL(vp, VOFFSET(vop_getacl), &a)); 1947 vop_post(vp, mp, mpsafe, FST_YES); 1948 return error; 1949 } 1950 1951 const int vop_setacl_vp_offsets[] = { 1952 VOPARG_OFFSETOF(struct vop_setacl_args,a_vp), 1953 VDESC_NO_OFFSET 1954 }; 1955 const struct vnodeop_desc vop_setacl_desc = { 1956 VOP_SETACL_DESCOFFSET, 1957 "vop_setacl", 1958 0, 1959 vop_setacl_vp_offsets, 1960 VDESC_NO_OFFSET, 1961 VOPARG_OFFSETOF(struct vop_setacl_args, a_cred), 1962 VDESC_NO_OFFSET, 1963 }; 1964 int 1965 VOP_SETACL(struct vnode *vp, 1966 acl_type_t type, 1967 struct acl *aclp, 1968 kauth_cred_t cred) 1969 { 1970 int error; 1971 bool mpsafe; 1972 struct vop_setacl_args a; 1973 struct mount *mp; 1974 a.a_desc = VDESC(vop_setacl); 1975 a.a_vp = vp; 1976 a.a_type = type; 1977 a.a_aclp = aclp; 1978 a.a_cred = cred; 1979 error = vop_pre(vp, &mp, &mpsafe, FST_YES); 1980 if (error) 1981 return error; 1982 error = (VCALL(vp, VOFFSET(vop_setacl), &a)); 1983 vop_post(vp, mp, mpsafe, FST_YES); 1984 vop_setacl_post(&a, error); 1985 return error; 1986 } 1987 1988 const int vop_aclcheck_vp_offsets[] = { 1989 VOPARG_OFFSETOF(struct vop_aclcheck_args,a_vp), 1990 VDESC_NO_OFFSET 1991 }; 1992 const struct vnodeop_desc vop_aclcheck_desc = { 1993 VOP_ACLCHECK_DESCOFFSET, 1994 "vop_aclcheck", 1995 0, 1996 vop_aclcheck_vp_offsets, 1997 VDESC_NO_OFFSET, 1998 VOPARG_OFFSETOF(struct vop_aclcheck_args, a_cred), 1999 VDESC_NO_OFFSET, 2000 }; 2001 int 2002 VOP_ACLCHECK(struct vnode *vp, 2003 acl_type_t type, 2004 struct acl *aclp, 2005 kauth_cred_t cred) 2006 { 2007 int error; 2008 bool mpsafe; 2009 struct vop_aclcheck_args a; 2010 struct mount *mp; 2011 a.a_desc = VDESC(vop_aclcheck); 2012 a.a_vp = vp; 2013 a.a_type = type; 2014 a.a_aclp = aclp; 2015 a.a_cred = cred; 2016 error = vop_pre(vp, &mp, &mpsafe, FST_YES); 2017 if (error) 2018 return error; 2019 error = (VCALL(vp, VOFFSET(vop_aclcheck), &a)); 2020 vop_post(vp, mp, mpsafe, FST_YES); 2021 return error; 2022 } 2023 2024 const int vop_closeextattr_vp_offsets[] = { 2025 VOPARG_OFFSETOF(struct vop_closeextattr_args,a_vp), 2026 VDESC_NO_OFFSET 2027 }; 2028 const struct vnodeop_desc vop_closeextattr_desc = { 2029 VOP_CLOSEEXTATTR_DESCOFFSET, 2030 "vop_closeextattr", 2031 0, 2032 vop_closeextattr_vp_offsets, 2033 VDESC_NO_OFFSET, 2034 VOPARG_OFFSETOF(struct vop_closeextattr_args, a_cred), 2035 VDESC_NO_OFFSET, 2036 }; 2037 int 2038 VOP_CLOSEEXTATTR(struct vnode *vp, 2039 int commit, 2040 kauth_cred_t cred) 2041 { 2042 int error; 2043 bool mpsafe; 2044 struct vop_closeextattr_args a; 2045 struct mount *mp; 2046 a.a_desc = VDESC(vop_closeextattr); 2047 a.a_vp = vp; 2048 a.a_commit = commit; 2049 a.a_cred = cred; 2050 error = vop_pre(vp, &mp, &mpsafe, FST_NO); 2051 if (error) 2052 return error; 2053 error = (VCALL(vp, VOFFSET(vop_closeextattr), &a)); 2054 vop_post(vp, mp, mpsafe, FST_NO); 2055 return error; 2056 } 2057 2058 const int vop_getextattr_vp_offsets[] = { 2059 VOPARG_OFFSETOF(struct vop_getextattr_args,a_vp), 2060 VDESC_NO_OFFSET 2061 }; 2062 const struct vnodeop_desc vop_getextattr_desc = { 2063 VOP_GETEXTATTR_DESCOFFSET, 2064 "vop_getextattr", 2065 0, 2066 vop_getextattr_vp_offsets, 2067 VDESC_NO_OFFSET, 2068 VOPARG_OFFSETOF(struct vop_getextattr_args, a_cred), 2069 VDESC_NO_OFFSET, 2070 }; 2071 int 2072 VOP_GETEXTATTR(struct vnode *vp, 2073 int attrnamespace, 2074 const char *name, 2075 struct uio *uio, 2076 size_t *size, 2077 kauth_cred_t cred) 2078 { 2079 int error; 2080 bool mpsafe; 2081 struct vop_getextattr_args a; 2082 struct mount *mp; 2083 a.a_desc = VDESC(vop_getextattr); 2084 a.a_vp = vp; 2085 a.a_attrnamespace = attrnamespace; 2086 a.a_name = name; 2087 a.a_uio = uio; 2088 a.a_size = size; 2089 a.a_cred = cred; 2090 error = vop_pre(vp, &mp, &mpsafe, FST_NO); 2091 if (error) 2092 return error; 2093 error = (VCALL(vp, VOFFSET(vop_getextattr), &a)); 2094 vop_post(vp, mp, mpsafe, FST_NO); 2095 return error; 2096 } 2097 2098 const int vop_listextattr_vp_offsets[] = { 2099 VOPARG_OFFSETOF(struct vop_listextattr_args,a_vp), 2100 VDESC_NO_OFFSET 2101 }; 2102 const struct vnodeop_desc vop_listextattr_desc = { 2103 VOP_LISTEXTATTR_DESCOFFSET, 2104 "vop_listextattr", 2105 0, 2106 vop_listextattr_vp_offsets, 2107 VDESC_NO_OFFSET, 2108 VOPARG_OFFSETOF(struct vop_listextattr_args, a_cred), 2109 VDESC_NO_OFFSET, 2110 }; 2111 int 2112 VOP_LISTEXTATTR(struct vnode *vp, 2113 int attrnamespace, 2114 struct uio *uio, 2115 size_t *size, 2116 int flag, 2117 kauth_cred_t cred) 2118 { 2119 int error; 2120 bool mpsafe; 2121 struct vop_listextattr_args a; 2122 struct mount *mp; 2123 a.a_desc = VDESC(vop_listextattr); 2124 a.a_vp = vp; 2125 a.a_attrnamespace = attrnamespace; 2126 a.a_uio = uio; 2127 a.a_size = size; 2128 a.a_flag = flag; 2129 a.a_cred = cred; 2130 error = vop_pre(vp, &mp, &mpsafe, FST_NO); 2131 if (error) 2132 return error; 2133 error = (VCALL(vp, VOFFSET(vop_listextattr), &a)); 2134 vop_post(vp, mp, mpsafe, FST_NO); 2135 return error; 2136 } 2137 2138 const int vop_openextattr_vp_offsets[] = { 2139 VOPARG_OFFSETOF(struct vop_openextattr_args,a_vp), 2140 VDESC_NO_OFFSET 2141 }; 2142 const struct vnodeop_desc vop_openextattr_desc = { 2143 VOP_OPENEXTATTR_DESCOFFSET, 2144 "vop_openextattr", 2145 0, 2146 vop_openextattr_vp_offsets, 2147 VDESC_NO_OFFSET, 2148 VOPARG_OFFSETOF(struct vop_openextattr_args, a_cred), 2149 VDESC_NO_OFFSET, 2150 }; 2151 int 2152 VOP_OPENEXTATTR(struct vnode *vp, 2153 kauth_cred_t cred) 2154 { 2155 int error; 2156 bool mpsafe; 2157 struct vop_openextattr_args a; 2158 struct mount *mp; 2159 a.a_desc = VDESC(vop_openextattr); 2160 a.a_vp = vp; 2161 a.a_cred = cred; 2162 error = vop_pre(vp, &mp, &mpsafe, FST_NO); 2163 if (error) 2164 return error; 2165 error = (VCALL(vp, VOFFSET(vop_openextattr), &a)); 2166 vop_post(vp, mp, mpsafe, FST_NO); 2167 return error; 2168 } 2169 2170 const int vop_deleteextattr_vp_offsets[] = { 2171 VOPARG_OFFSETOF(struct vop_deleteextattr_args,a_vp), 2172 VDESC_NO_OFFSET 2173 }; 2174 const struct vnodeop_desc vop_deleteextattr_desc = { 2175 VOP_DELETEEXTATTR_DESCOFFSET, 2176 "vop_deleteextattr", 2177 0, 2178 vop_deleteextattr_vp_offsets, 2179 VDESC_NO_OFFSET, 2180 VOPARG_OFFSETOF(struct vop_deleteextattr_args, a_cred), 2181 VDESC_NO_OFFSET, 2182 }; 2183 int 2184 VOP_DELETEEXTATTR(struct vnode *vp, 2185 int attrnamespace, 2186 const char *name, 2187 kauth_cred_t cred) 2188 { 2189 int error; 2190 bool mpsafe; 2191 struct vop_deleteextattr_args a; 2192 struct mount *mp; 2193 a.a_desc = VDESC(vop_deleteextattr); 2194 a.a_vp = vp; 2195 a.a_attrnamespace = attrnamespace; 2196 a.a_name = name; 2197 a.a_cred = cred; 2198 error = vop_pre(vp, &mp, &mpsafe, FST_NO); 2199 if (error) 2200 return error; 2201 error = (VCALL(vp, VOFFSET(vop_deleteextattr), &a)); 2202 vop_post(vp, mp, mpsafe, FST_NO); 2203 return error; 2204 } 2205 2206 const int vop_setextattr_vp_offsets[] = { 2207 VOPARG_OFFSETOF(struct vop_setextattr_args,a_vp), 2208 VDESC_NO_OFFSET 2209 }; 2210 const struct vnodeop_desc vop_setextattr_desc = { 2211 VOP_SETEXTATTR_DESCOFFSET, 2212 "vop_setextattr", 2213 0, 2214 vop_setextattr_vp_offsets, 2215 VDESC_NO_OFFSET, 2216 VOPARG_OFFSETOF(struct vop_setextattr_args, a_cred), 2217 VDESC_NO_OFFSET, 2218 }; 2219 int 2220 VOP_SETEXTATTR(struct vnode *vp, 2221 int attrnamespace, 2222 const char *name, 2223 struct uio *uio, 2224 kauth_cred_t cred) 2225 { 2226 int error; 2227 bool mpsafe; 2228 struct vop_setextattr_args a; 2229 struct mount *mp; 2230 a.a_desc = VDESC(vop_setextattr); 2231 a.a_vp = vp; 2232 a.a_attrnamespace = attrnamespace; 2233 a.a_name = name; 2234 a.a_uio = uio; 2235 a.a_cred = cred; 2236 error = vop_pre(vp, &mp, &mpsafe, FST_NO); 2237 if (error) 2238 return error; 2239 error = (VCALL(vp, VOFFSET(vop_setextattr), &a)); 2240 vop_post(vp, mp, mpsafe, FST_NO); 2241 return error; 2242 } 2243 2244 const struct vnodeop_desc * const vfs_op_descs[] = { 2245 &vop_default_desc, /* MUST BE FIRST */ 2246 2247 &vop_bwrite_desc, 2248 &vop_parsepath_desc, 2249 &vop_lookup_desc, 2250 &vop_create_desc, 2251 &vop_mknod_desc, 2252 &vop_open_desc, 2253 &vop_close_desc, 2254 &vop_access_desc, 2255 &vop_accessx_desc, 2256 &vop_getattr_desc, 2257 &vop_setattr_desc, 2258 &vop_read_desc, 2259 &vop_write_desc, 2260 &vop_fallocate_desc, 2261 &vop_fdiscard_desc, 2262 &vop_ioctl_desc, 2263 &vop_fcntl_desc, 2264 &vop_poll_desc, 2265 &vop_kqfilter_desc, 2266 &vop_revoke_desc, 2267 &vop_mmap_desc, 2268 &vop_fsync_desc, 2269 &vop_seek_desc, 2270 &vop_remove_desc, 2271 &vop_link_desc, 2272 &vop_rename_desc, 2273 &vop_mkdir_desc, 2274 &vop_rmdir_desc, 2275 &vop_symlink_desc, 2276 &vop_readdir_desc, 2277 &vop_readlink_desc, 2278 &vop_abortop_desc, 2279 &vop_inactive_desc, 2280 &vop_reclaim_desc, 2281 &vop_lock_desc, 2282 &vop_unlock_desc, 2283 &vop_bmap_desc, 2284 &vop_strategy_desc, 2285 &vop_print_desc, 2286 &vop_islocked_desc, 2287 &vop_pathconf_desc, 2288 &vop_advlock_desc, 2289 &vop_whiteout_desc, 2290 &vop_getpages_desc, 2291 &vop_putpages_desc, 2292 &vop_getacl_desc, 2293 &vop_setacl_desc, 2294 &vop_aclcheck_desc, 2295 &vop_closeextattr_desc, 2296 &vop_getextattr_desc, 2297 &vop_listextattr_desc, 2298 &vop_openextattr_desc, 2299 &vop_deleteextattr_desc, 2300 &vop_setextattr_desc, 2301 NULL 2302 }; 2303