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