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