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