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