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