vnode_if.c revision 1.34
1 /* $NetBSD: vnode_if.c,v 1.34 2001/05/07 08:48:07 lukem Exp $ */ 2 3 /* 4 * Warning: This file is generated automatically. 5 * (Modifications made here may easily be lost!) 6 * 7 * Created from the file: 8 * NetBSD: vnode_if.src,v 1.26 2000/11/27 08:39:45 chs Exp 9 * by the script: 10 * NetBSD: vnode_if.sh,v 1.29 2001/05/07 08:46:02 lukem 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. All advertising materials mentioning features or use of this software 26 * must display the following acknowledgement: 27 * This product includes software developed by the University of 28 * California, Berkeley and its contributors. 29 * 4. Neither the name of the University nor the names of its contributors 30 * may be used to endorse or promote products derived from this software 31 * without specific prior written permission. 32 * 33 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 34 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 35 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 36 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 37 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 38 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 39 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 40 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 41 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 42 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 43 * SUCH DAMAGE. 44 */ 45 46 /* 47 * If we have LKM support, always include the non-inline versions for 48 * LKMs. Otherwise, do it based on the option. 49 */ 50 #ifdef LKM 51 #define VNODE_OP_NOINLINE 52 #else 53 #include "opt_vnode_op_noinline.h" 54 #endif 55 56 #include <sys/param.h> 57 #include <sys/mount.h> 58 #include <sys/buf.h> 59 #include <sys/vnode.h> 60 61 const struct vnodeop_desc vop_default_desc = { 62 0, 63 "default", 64 0, 65 NULL, 66 VDESC_NO_OFFSET, 67 VDESC_NO_OFFSET, 68 VDESC_NO_OFFSET, 69 VDESC_NO_OFFSET, 70 NULL, 71 }; 72 73 74 /* Special cases: */ 75 76 const int vop_strategy_vp_offsets[] = { 77 VDESC_NO_OFFSET 78 }; 79 const struct vnodeop_desc vop_strategy_desc = { 80 1, 81 "vop_strategy", 82 0, 83 vop_strategy_vp_offsets, 84 VDESC_NO_OFFSET, 85 VDESC_NO_OFFSET, 86 VDESC_NO_OFFSET, 87 VDESC_NO_OFFSET, 88 NULL, 89 }; 90 #ifdef VNODE_OP_NOINLINE 91 int 92 VOP_STRATEGY(bp) 93 struct buf *bp; 94 { 95 struct vop_strategy_args a; 96 a.a_desc = VDESC(vop_strategy); 97 a.a_bp = bp; 98 return (VCALL(bp->b_vp, VOFFSET(vop_strategy), &a)); 99 } 100 #endif 101 102 const int vop_bwrite_vp_offsets[] = { 103 VDESC_NO_OFFSET 104 }; 105 const struct vnodeop_desc vop_bwrite_desc = { 106 2, 107 "vop_bwrite", 108 0, 109 vop_bwrite_vp_offsets, 110 VDESC_NO_OFFSET, 111 VDESC_NO_OFFSET, 112 VDESC_NO_OFFSET, 113 VDESC_NO_OFFSET, 114 NULL, 115 }; 116 #ifdef VNODE_OP_NOINLINE 117 int 118 VOP_BWRITE(bp) 119 struct buf *bp; 120 { 121 struct vop_bwrite_args a; 122 a.a_desc = VDESC(vop_bwrite); 123 a.a_bp = bp; 124 return (VCALL(bp->b_vp, VOFFSET(vop_bwrite), &a)); 125 } 126 #endif 127 128 /* End of special cases */ 129 130 const int vop_lookup_vp_offsets[] = { 131 VOPARG_OFFSETOF(struct vop_lookup_args,a_dvp), 132 VDESC_NO_OFFSET 133 }; 134 const struct vnodeop_desc vop_lookup_desc = { 135 3, 136 "vop_lookup", 137 0, 138 vop_lookup_vp_offsets, 139 VOPARG_OFFSETOF(struct vop_lookup_args, a_vpp), 140 VDESC_NO_OFFSET, 141 VDESC_NO_OFFSET, 142 VOPARG_OFFSETOF(struct vop_lookup_args, a_cnp), 143 NULL, 144 }; 145 #ifdef VNODE_OP_NOINLINE 146 int 147 VOP_LOOKUP(dvp, vpp, cnp) 148 struct vnode *dvp; 149 struct vnode **vpp; 150 struct componentname *cnp; 151 { 152 struct vop_lookup_args a; 153 a.a_desc = VDESC(vop_lookup); 154 a.a_dvp = dvp; 155 a.a_vpp = vpp; 156 a.a_cnp = cnp; 157 return (VCALL(dvp, VOFFSET(vop_lookup), &a)); 158 } 159 #endif 160 161 const int vop_create_vp_offsets[] = { 162 VOPARG_OFFSETOF(struct vop_create_args,a_dvp), 163 VDESC_NO_OFFSET 164 }; 165 const struct vnodeop_desc vop_create_desc = { 166 4, 167 "vop_create", 168 0 | VDESC_VP0_WILLPUT, 169 vop_create_vp_offsets, 170 VOPARG_OFFSETOF(struct vop_create_args, a_vpp), 171 VDESC_NO_OFFSET, 172 VDESC_NO_OFFSET, 173 VOPARG_OFFSETOF(struct vop_create_args, a_cnp), 174 NULL, 175 }; 176 #ifdef VNODE_OP_NOINLINE 177 int 178 VOP_CREATE(dvp, vpp, cnp, vap) 179 struct vnode *dvp; 180 struct vnode **vpp; 181 struct componentname *cnp; 182 struct vattr *vap; 183 { 184 struct vop_create_args a; 185 a.a_desc = VDESC(vop_create); 186 a.a_dvp = dvp; 187 a.a_vpp = vpp; 188 a.a_cnp = cnp; 189 a.a_vap = vap; 190 return (VCALL(dvp, VOFFSET(vop_create), &a)); 191 } 192 #endif 193 194 const int vop_mknod_vp_offsets[] = { 195 VOPARG_OFFSETOF(struct vop_mknod_args,a_dvp), 196 VDESC_NO_OFFSET 197 }; 198 const struct vnodeop_desc vop_mknod_desc = { 199 5, 200 "vop_mknod", 201 0 | VDESC_VP0_WILLPUT | VDESC_VPP_WILLRELE, 202 vop_mknod_vp_offsets, 203 VOPARG_OFFSETOF(struct vop_mknod_args, a_vpp), 204 VDESC_NO_OFFSET, 205 VDESC_NO_OFFSET, 206 VOPARG_OFFSETOF(struct vop_mknod_args, a_cnp), 207 NULL, 208 }; 209 #ifdef VNODE_OP_NOINLINE 210 int 211 VOP_MKNOD(dvp, vpp, cnp, vap) 212 struct vnode *dvp; 213 struct vnode **vpp; 214 struct componentname *cnp; 215 struct vattr *vap; 216 { 217 struct vop_mknod_args a; 218 a.a_desc = VDESC(vop_mknod); 219 a.a_dvp = dvp; 220 a.a_vpp = vpp; 221 a.a_cnp = cnp; 222 a.a_vap = vap; 223 return (VCALL(dvp, VOFFSET(vop_mknod), &a)); 224 } 225 #endif 226 227 const int vop_open_vp_offsets[] = { 228 VOPARG_OFFSETOF(struct vop_open_args,a_vp), 229 VDESC_NO_OFFSET 230 }; 231 const struct vnodeop_desc vop_open_desc = { 232 6, 233 "vop_open", 234 0, 235 vop_open_vp_offsets, 236 VDESC_NO_OFFSET, 237 VOPARG_OFFSETOF(struct vop_open_args, a_cred), 238 VOPARG_OFFSETOF(struct vop_open_args, a_p), 239 VDESC_NO_OFFSET, 240 NULL, 241 }; 242 #ifdef VNODE_OP_NOINLINE 243 int 244 VOP_OPEN(vp, mode, cred, p) 245 struct vnode *vp; 246 int mode; 247 struct ucred *cred; 248 struct proc *p; 249 { 250 struct vop_open_args a; 251 a.a_desc = VDESC(vop_open); 252 a.a_vp = vp; 253 a.a_mode = mode; 254 a.a_cred = cred; 255 a.a_p = p; 256 return (VCALL(vp, VOFFSET(vop_open), &a)); 257 } 258 #endif 259 260 const int vop_close_vp_offsets[] = { 261 VOPARG_OFFSETOF(struct vop_close_args,a_vp), 262 VDESC_NO_OFFSET 263 }; 264 const struct vnodeop_desc vop_close_desc = { 265 7, 266 "vop_close", 267 0, 268 vop_close_vp_offsets, 269 VDESC_NO_OFFSET, 270 VOPARG_OFFSETOF(struct vop_close_args, a_cred), 271 VOPARG_OFFSETOF(struct vop_close_args, a_p), 272 VDESC_NO_OFFSET, 273 NULL, 274 }; 275 #ifdef VNODE_OP_NOINLINE 276 int 277 VOP_CLOSE(vp, fflag, cred, p) 278 struct vnode *vp; 279 int fflag; 280 struct ucred *cred; 281 struct proc *p; 282 { 283 struct vop_close_args a; 284 a.a_desc = VDESC(vop_close); 285 a.a_vp = vp; 286 a.a_fflag = fflag; 287 a.a_cred = cred; 288 a.a_p = p; 289 return (VCALL(vp, VOFFSET(vop_close), &a)); 290 } 291 #endif 292 293 const int vop_access_vp_offsets[] = { 294 VOPARG_OFFSETOF(struct vop_access_args,a_vp), 295 VDESC_NO_OFFSET 296 }; 297 const struct vnodeop_desc vop_access_desc = { 298 8, 299 "vop_access", 300 0, 301 vop_access_vp_offsets, 302 VDESC_NO_OFFSET, 303 VOPARG_OFFSETOF(struct vop_access_args, a_cred), 304 VOPARG_OFFSETOF(struct vop_access_args, a_p), 305 VDESC_NO_OFFSET, 306 NULL, 307 }; 308 #ifdef VNODE_OP_NOINLINE 309 int 310 VOP_ACCESS(vp, mode, cred, p) 311 struct vnode *vp; 312 int mode; 313 struct ucred *cred; 314 struct proc *p; 315 { 316 struct vop_access_args a; 317 a.a_desc = VDESC(vop_access); 318 a.a_vp = vp; 319 a.a_mode = mode; 320 a.a_cred = cred; 321 a.a_p = p; 322 return (VCALL(vp, VOFFSET(vop_access), &a)); 323 } 324 #endif 325 326 const int vop_getattr_vp_offsets[] = { 327 VOPARG_OFFSETOF(struct vop_getattr_args,a_vp), 328 VDESC_NO_OFFSET 329 }; 330 const struct vnodeop_desc vop_getattr_desc = { 331 9, 332 "vop_getattr", 333 0, 334 vop_getattr_vp_offsets, 335 VDESC_NO_OFFSET, 336 VOPARG_OFFSETOF(struct vop_getattr_args, a_cred), 337 VOPARG_OFFSETOF(struct vop_getattr_args, a_p), 338 VDESC_NO_OFFSET, 339 NULL, 340 }; 341 #ifdef VNODE_OP_NOINLINE 342 int 343 VOP_GETATTR(vp, vap, cred, p) 344 struct vnode *vp; 345 struct vattr *vap; 346 struct ucred *cred; 347 struct proc *p; 348 { 349 struct vop_getattr_args a; 350 a.a_desc = VDESC(vop_getattr); 351 a.a_vp = vp; 352 a.a_vap = vap; 353 a.a_cred = cred; 354 a.a_p = p; 355 return (VCALL(vp, VOFFSET(vop_getattr), &a)); 356 } 357 #endif 358 359 const int vop_setattr_vp_offsets[] = { 360 VOPARG_OFFSETOF(struct vop_setattr_args,a_vp), 361 VDESC_NO_OFFSET 362 }; 363 const struct vnodeop_desc vop_setattr_desc = { 364 10, 365 "vop_setattr", 366 0, 367 vop_setattr_vp_offsets, 368 VDESC_NO_OFFSET, 369 VOPARG_OFFSETOF(struct vop_setattr_args, a_cred), 370 VOPARG_OFFSETOF(struct vop_setattr_args, a_p), 371 VDESC_NO_OFFSET, 372 NULL, 373 }; 374 #ifdef VNODE_OP_NOINLINE 375 int 376 VOP_SETATTR(vp, vap, cred, p) 377 struct vnode *vp; 378 struct vattr *vap; 379 struct ucred *cred; 380 struct proc *p; 381 { 382 struct vop_setattr_args a; 383 a.a_desc = VDESC(vop_setattr); 384 a.a_vp = vp; 385 a.a_vap = vap; 386 a.a_cred = cred; 387 a.a_p = p; 388 return (VCALL(vp, VOFFSET(vop_setattr), &a)); 389 } 390 #endif 391 392 const int vop_read_vp_offsets[] = { 393 VOPARG_OFFSETOF(struct vop_read_args,a_vp), 394 VDESC_NO_OFFSET 395 }; 396 const struct vnodeop_desc vop_read_desc = { 397 11, 398 "vop_read", 399 0, 400 vop_read_vp_offsets, 401 VDESC_NO_OFFSET, 402 VOPARG_OFFSETOF(struct vop_read_args, a_cred), 403 VDESC_NO_OFFSET, 404 VDESC_NO_OFFSET, 405 NULL, 406 }; 407 #ifdef VNODE_OP_NOINLINE 408 int 409 VOP_READ(vp, uio, ioflag, cred) 410 struct vnode *vp; 411 struct uio *uio; 412 int ioflag; 413 struct ucred *cred; 414 { 415 struct vop_read_args a; 416 a.a_desc = VDESC(vop_read); 417 a.a_vp = vp; 418 a.a_uio = uio; 419 a.a_ioflag = ioflag; 420 a.a_cred = cred; 421 return (VCALL(vp, VOFFSET(vop_read), &a)); 422 } 423 #endif 424 425 const int vop_write_vp_offsets[] = { 426 VOPARG_OFFSETOF(struct vop_write_args,a_vp), 427 VDESC_NO_OFFSET 428 }; 429 const struct vnodeop_desc vop_write_desc = { 430 12, 431 "vop_write", 432 0, 433 vop_write_vp_offsets, 434 VDESC_NO_OFFSET, 435 VOPARG_OFFSETOF(struct vop_write_args, a_cred), 436 VDESC_NO_OFFSET, 437 VDESC_NO_OFFSET, 438 NULL, 439 }; 440 #ifdef VNODE_OP_NOINLINE 441 int 442 VOP_WRITE(vp, uio, ioflag, cred) 443 struct vnode *vp; 444 struct uio *uio; 445 int ioflag; 446 struct ucred *cred; 447 { 448 struct vop_write_args a; 449 a.a_desc = VDESC(vop_write); 450 a.a_vp = vp; 451 a.a_uio = uio; 452 a.a_ioflag = ioflag; 453 a.a_cred = cred; 454 return (VCALL(vp, VOFFSET(vop_write), &a)); 455 } 456 #endif 457 458 const int vop_ioctl_vp_offsets[] = { 459 VOPARG_OFFSETOF(struct vop_ioctl_args,a_vp), 460 VDESC_NO_OFFSET 461 }; 462 const struct vnodeop_desc vop_ioctl_desc = { 463 13, 464 "vop_ioctl", 465 0, 466 vop_ioctl_vp_offsets, 467 VDESC_NO_OFFSET, 468 VOPARG_OFFSETOF(struct vop_ioctl_args, a_cred), 469 VOPARG_OFFSETOF(struct vop_ioctl_args, a_p), 470 VDESC_NO_OFFSET, 471 NULL, 472 }; 473 #ifdef VNODE_OP_NOINLINE 474 int 475 VOP_IOCTL(vp, command, data, fflag, cred, p) 476 struct vnode *vp; 477 u_long command; 478 caddr_t data; 479 int fflag; 480 struct ucred *cred; 481 struct proc *p; 482 { 483 struct vop_ioctl_args a; 484 a.a_desc = VDESC(vop_ioctl); 485 a.a_vp = vp; 486 a.a_command = command; 487 a.a_data = data; 488 a.a_fflag = fflag; 489 a.a_cred = cred; 490 a.a_p = p; 491 return (VCALL(vp, VOFFSET(vop_ioctl), &a)); 492 } 493 #endif 494 495 const int vop_fcntl_vp_offsets[] = { 496 VOPARG_OFFSETOF(struct vop_fcntl_args,a_vp), 497 VDESC_NO_OFFSET 498 }; 499 const struct vnodeop_desc vop_fcntl_desc = { 500 14, 501 "vop_fcntl", 502 0, 503 vop_fcntl_vp_offsets, 504 VDESC_NO_OFFSET, 505 VOPARG_OFFSETOF(struct vop_fcntl_args, a_cred), 506 VOPARG_OFFSETOF(struct vop_fcntl_args, a_p), 507 VDESC_NO_OFFSET, 508 NULL, 509 }; 510 #ifdef VNODE_OP_NOINLINE 511 int 512 VOP_FCNTL(vp, command, data, fflag, cred, p) 513 struct vnode *vp; 514 u_int command; 515 caddr_t data; 516 int fflag; 517 struct ucred *cred; 518 struct proc *p; 519 { 520 struct vop_fcntl_args a; 521 a.a_desc = VDESC(vop_fcntl); 522 a.a_vp = vp; 523 a.a_command = command; 524 a.a_data = data; 525 a.a_fflag = fflag; 526 a.a_cred = cred; 527 a.a_p = p; 528 return (VCALL(vp, VOFFSET(vop_fcntl), &a)); 529 } 530 #endif 531 532 const int vop_poll_vp_offsets[] = { 533 VOPARG_OFFSETOF(struct vop_poll_args,a_vp), 534 VDESC_NO_OFFSET 535 }; 536 const struct vnodeop_desc vop_poll_desc = { 537 15, 538 "vop_poll", 539 0, 540 vop_poll_vp_offsets, 541 VDESC_NO_OFFSET, 542 VDESC_NO_OFFSET, 543 VOPARG_OFFSETOF(struct vop_poll_args, a_p), 544 VDESC_NO_OFFSET, 545 NULL, 546 }; 547 #ifdef VNODE_OP_NOINLINE 548 int 549 VOP_POLL(vp, events, p) 550 struct vnode *vp; 551 int events; 552 struct proc *p; 553 { 554 struct vop_poll_args a; 555 a.a_desc = VDESC(vop_poll); 556 a.a_vp = vp; 557 a.a_events = events; 558 a.a_p = p; 559 return (VCALL(vp, VOFFSET(vop_poll), &a)); 560 } 561 #endif 562 563 const int vop_revoke_vp_offsets[] = { 564 VOPARG_OFFSETOF(struct vop_revoke_args,a_vp), 565 VDESC_NO_OFFSET 566 }; 567 const struct vnodeop_desc vop_revoke_desc = { 568 16, 569 "vop_revoke", 570 0, 571 vop_revoke_vp_offsets, 572 VDESC_NO_OFFSET, 573 VDESC_NO_OFFSET, 574 VDESC_NO_OFFSET, 575 VDESC_NO_OFFSET, 576 NULL, 577 }; 578 #ifdef VNODE_OP_NOINLINE 579 int 580 VOP_REVOKE(vp, flags) 581 struct vnode *vp; 582 int flags; 583 { 584 struct vop_revoke_args a; 585 a.a_desc = VDESC(vop_revoke); 586 a.a_vp = vp; 587 a.a_flags = flags; 588 return (VCALL(vp, VOFFSET(vop_revoke), &a)); 589 } 590 #endif 591 592 const int vop_mmap_vp_offsets[] = { 593 VOPARG_OFFSETOF(struct vop_mmap_args,a_vp), 594 VDESC_NO_OFFSET 595 }; 596 const struct vnodeop_desc vop_mmap_desc = { 597 17, 598 "vop_mmap", 599 0, 600 vop_mmap_vp_offsets, 601 VDESC_NO_OFFSET, 602 VOPARG_OFFSETOF(struct vop_mmap_args, a_cred), 603 VOPARG_OFFSETOF(struct vop_mmap_args, a_p), 604 VDESC_NO_OFFSET, 605 NULL, 606 }; 607 #ifdef VNODE_OP_NOINLINE 608 int 609 VOP_MMAP(vp, fflags, cred, p) 610 struct vnode *vp; 611 int fflags; 612 struct ucred *cred; 613 struct proc *p; 614 { 615 struct vop_mmap_args a; 616 a.a_desc = VDESC(vop_mmap); 617 a.a_vp = vp; 618 a.a_fflags = fflags; 619 a.a_cred = cred; 620 a.a_p = p; 621 return (VCALL(vp, VOFFSET(vop_mmap), &a)); 622 } 623 #endif 624 625 const int vop_fsync_vp_offsets[] = { 626 VOPARG_OFFSETOF(struct vop_fsync_args,a_vp), 627 VDESC_NO_OFFSET 628 }; 629 const struct vnodeop_desc vop_fsync_desc = { 630 18, 631 "vop_fsync", 632 0, 633 vop_fsync_vp_offsets, 634 VDESC_NO_OFFSET, 635 VOPARG_OFFSETOF(struct vop_fsync_args, a_cred), 636 VOPARG_OFFSETOF(struct vop_fsync_args, a_p), 637 VDESC_NO_OFFSET, 638 NULL, 639 }; 640 #ifdef VNODE_OP_NOINLINE 641 int 642 VOP_FSYNC(vp, cred, flags, offlo, offhi, p) 643 struct vnode *vp; 644 struct ucred *cred; 645 int flags; 646 off_t offlo; 647 off_t offhi; 648 struct proc *p; 649 { 650 struct vop_fsync_args a; 651 a.a_desc = VDESC(vop_fsync); 652 a.a_vp = vp; 653 a.a_cred = cred; 654 a.a_flags = flags; 655 a.a_offlo = offlo; 656 a.a_offhi = offhi; 657 a.a_p = p; 658 return (VCALL(vp, VOFFSET(vop_fsync), &a)); 659 } 660 #endif 661 662 const int vop_seek_vp_offsets[] = { 663 VOPARG_OFFSETOF(struct vop_seek_args,a_vp), 664 VDESC_NO_OFFSET 665 }; 666 const struct vnodeop_desc vop_seek_desc = { 667 19, 668 "vop_seek", 669 0, 670 vop_seek_vp_offsets, 671 VDESC_NO_OFFSET, 672 VOPARG_OFFSETOF(struct vop_seek_args, a_cred), 673 VDESC_NO_OFFSET, 674 VDESC_NO_OFFSET, 675 NULL, 676 }; 677 #ifdef VNODE_OP_NOINLINE 678 int 679 VOP_SEEK(vp, oldoff, newoff, cred) 680 struct vnode *vp; 681 off_t oldoff; 682 off_t newoff; 683 struct ucred *cred; 684 { 685 struct vop_seek_args a; 686 a.a_desc = VDESC(vop_seek); 687 a.a_vp = vp; 688 a.a_oldoff = oldoff; 689 a.a_newoff = newoff; 690 a.a_cred = cred; 691 return (VCALL(vp, VOFFSET(vop_seek), &a)); 692 } 693 #endif 694 695 const int vop_remove_vp_offsets[] = { 696 VOPARG_OFFSETOF(struct vop_remove_args,a_dvp), 697 VOPARG_OFFSETOF(struct vop_remove_args,a_vp), 698 VDESC_NO_OFFSET 699 }; 700 const struct vnodeop_desc vop_remove_desc = { 701 20, 702 "vop_remove", 703 0 | VDESC_VP0_WILLPUT | VDESC_VP1_WILLPUT, 704 vop_remove_vp_offsets, 705 VDESC_NO_OFFSET, 706 VDESC_NO_OFFSET, 707 VDESC_NO_OFFSET, 708 VOPARG_OFFSETOF(struct vop_remove_args, a_cnp), 709 NULL, 710 }; 711 #ifdef VNODE_OP_NOINLINE 712 int 713 VOP_REMOVE(dvp, vp, cnp) 714 struct vnode *dvp; 715 struct vnode *vp; 716 struct componentname *cnp; 717 { 718 struct vop_remove_args a; 719 a.a_desc = VDESC(vop_remove); 720 a.a_dvp = dvp; 721 a.a_vp = vp; 722 a.a_cnp = cnp; 723 return (VCALL(dvp, VOFFSET(vop_remove), &a)); 724 } 725 #endif 726 727 const int vop_link_vp_offsets[] = { 728 VOPARG_OFFSETOF(struct vop_link_args,a_dvp), 729 VOPARG_OFFSETOF(struct vop_link_args,a_vp), 730 VDESC_NO_OFFSET 731 }; 732 const struct vnodeop_desc vop_link_desc = { 733 21, 734 "vop_link", 735 0 | VDESC_VP0_WILLPUT, 736 vop_link_vp_offsets, 737 VDESC_NO_OFFSET, 738 VDESC_NO_OFFSET, 739 VDESC_NO_OFFSET, 740 VOPARG_OFFSETOF(struct vop_link_args, a_cnp), 741 NULL, 742 }; 743 #ifdef VNODE_OP_NOINLINE 744 int 745 VOP_LINK(dvp, vp, cnp) 746 struct vnode *dvp; 747 struct vnode *vp; 748 struct componentname *cnp; 749 { 750 struct vop_link_args a; 751 a.a_desc = VDESC(vop_link); 752 a.a_dvp = dvp; 753 a.a_vp = vp; 754 a.a_cnp = cnp; 755 return (VCALL(dvp, VOFFSET(vop_link), &a)); 756 } 757 #endif 758 759 const int vop_rename_vp_offsets[] = { 760 VOPARG_OFFSETOF(struct vop_rename_args,a_fdvp), 761 VOPARG_OFFSETOF(struct vop_rename_args,a_fvp), 762 VOPARG_OFFSETOF(struct vop_rename_args,a_tdvp), 763 VOPARG_OFFSETOF(struct vop_rename_args,a_tvp), 764 VDESC_NO_OFFSET 765 }; 766 const struct vnodeop_desc vop_rename_desc = { 767 22, 768 "vop_rename", 769 0 | VDESC_VP0_WILLRELE | VDESC_VP1_WILLRELE | VDESC_VP2_WILLPUT | VDESC_VP3_WILLRELE, 770 vop_rename_vp_offsets, 771 VDESC_NO_OFFSET, 772 VDESC_NO_OFFSET, 773 VDESC_NO_OFFSET, 774 VOPARG_OFFSETOF(struct vop_rename_args, a_fcnp), 775 NULL, 776 }; 777 #ifdef VNODE_OP_NOINLINE 778 int 779 VOP_RENAME(fdvp, fvp, fcnp, tdvp, tvp, tcnp) 780 struct vnode *fdvp; 781 struct vnode *fvp; 782 struct componentname *fcnp; 783 struct vnode *tdvp; 784 struct vnode *tvp; 785 struct componentname *tcnp; 786 { 787 struct vop_rename_args a; 788 a.a_desc = VDESC(vop_rename); 789 a.a_fdvp = fdvp; 790 a.a_fvp = fvp; 791 a.a_fcnp = fcnp; 792 a.a_tdvp = tdvp; 793 a.a_tvp = tvp; 794 a.a_tcnp = tcnp; 795 return (VCALL(fdvp, VOFFSET(vop_rename), &a)); 796 } 797 #endif 798 799 const int vop_mkdir_vp_offsets[] = { 800 VOPARG_OFFSETOF(struct vop_mkdir_args,a_dvp), 801 VDESC_NO_OFFSET 802 }; 803 const struct vnodeop_desc vop_mkdir_desc = { 804 23, 805 "vop_mkdir", 806 0 | VDESC_VP0_WILLPUT, 807 vop_mkdir_vp_offsets, 808 VOPARG_OFFSETOF(struct vop_mkdir_args, a_vpp), 809 VDESC_NO_OFFSET, 810 VDESC_NO_OFFSET, 811 VOPARG_OFFSETOF(struct vop_mkdir_args, a_cnp), 812 NULL, 813 }; 814 #ifdef VNODE_OP_NOINLINE 815 int 816 VOP_MKDIR(dvp, vpp, cnp, vap) 817 struct vnode *dvp; 818 struct vnode **vpp; 819 struct componentname *cnp; 820 struct vattr *vap; 821 { 822 struct vop_mkdir_args a; 823 a.a_desc = VDESC(vop_mkdir); 824 a.a_dvp = dvp; 825 a.a_vpp = vpp; 826 a.a_cnp = cnp; 827 a.a_vap = vap; 828 return (VCALL(dvp, VOFFSET(vop_mkdir), &a)); 829 } 830 #endif 831 832 const int vop_rmdir_vp_offsets[] = { 833 VOPARG_OFFSETOF(struct vop_rmdir_args,a_dvp), 834 VOPARG_OFFSETOF(struct vop_rmdir_args,a_vp), 835 VDESC_NO_OFFSET 836 }; 837 const struct vnodeop_desc vop_rmdir_desc = { 838 24, 839 "vop_rmdir", 840 0 | VDESC_VP0_WILLPUT | VDESC_VP1_WILLPUT, 841 vop_rmdir_vp_offsets, 842 VDESC_NO_OFFSET, 843 VDESC_NO_OFFSET, 844 VDESC_NO_OFFSET, 845 VOPARG_OFFSETOF(struct vop_rmdir_args, a_cnp), 846 NULL, 847 }; 848 #ifdef VNODE_OP_NOINLINE 849 int 850 VOP_RMDIR(dvp, vp, cnp) 851 struct vnode *dvp; 852 struct vnode *vp; 853 struct componentname *cnp; 854 { 855 struct vop_rmdir_args a; 856 a.a_desc = VDESC(vop_rmdir); 857 a.a_dvp = dvp; 858 a.a_vp = vp; 859 a.a_cnp = cnp; 860 return (VCALL(dvp, VOFFSET(vop_rmdir), &a)); 861 } 862 #endif 863 864 const int vop_symlink_vp_offsets[] = { 865 VOPARG_OFFSETOF(struct vop_symlink_args,a_dvp), 866 VDESC_NO_OFFSET 867 }; 868 const struct vnodeop_desc vop_symlink_desc = { 869 25, 870 "vop_symlink", 871 0 | VDESC_VP0_WILLPUT | VDESC_VPP_WILLRELE, 872 vop_symlink_vp_offsets, 873 VOPARG_OFFSETOF(struct vop_symlink_args, a_vpp), 874 VDESC_NO_OFFSET, 875 VDESC_NO_OFFSET, 876 VOPARG_OFFSETOF(struct vop_symlink_args, a_cnp), 877 NULL, 878 }; 879 #ifdef VNODE_OP_NOINLINE 880 int 881 VOP_SYMLINK(dvp, vpp, cnp, vap, target) 882 struct vnode *dvp; 883 struct vnode **vpp; 884 struct componentname *cnp; 885 struct vattr *vap; 886 char *target; 887 { 888 struct vop_symlink_args a; 889 a.a_desc = VDESC(vop_symlink); 890 a.a_dvp = dvp; 891 a.a_vpp = vpp; 892 a.a_cnp = cnp; 893 a.a_vap = vap; 894 a.a_target = target; 895 return (VCALL(dvp, VOFFSET(vop_symlink), &a)); 896 } 897 #endif 898 899 const int vop_readdir_vp_offsets[] = { 900 VOPARG_OFFSETOF(struct vop_readdir_args,a_vp), 901 VDESC_NO_OFFSET 902 }; 903 const struct vnodeop_desc vop_readdir_desc = { 904 26, 905 "vop_readdir", 906 0, 907 vop_readdir_vp_offsets, 908 VDESC_NO_OFFSET, 909 VOPARG_OFFSETOF(struct vop_readdir_args, a_cred), 910 VDESC_NO_OFFSET, 911 VDESC_NO_OFFSET, 912 NULL, 913 }; 914 #ifdef VNODE_OP_NOINLINE 915 int 916 VOP_READDIR(vp, uio, cred, eofflag, cookies, ncookies) 917 struct vnode *vp; 918 struct uio *uio; 919 struct ucred *cred; 920 int *eofflag; 921 off_t **cookies; 922 int *ncookies; 923 { 924 struct vop_readdir_args a; 925 a.a_desc = VDESC(vop_readdir); 926 a.a_vp = vp; 927 a.a_uio = uio; 928 a.a_cred = cred; 929 a.a_eofflag = eofflag; 930 a.a_cookies = cookies; 931 a.a_ncookies = ncookies; 932 return (VCALL(vp, VOFFSET(vop_readdir), &a)); 933 } 934 #endif 935 936 const int vop_readlink_vp_offsets[] = { 937 VOPARG_OFFSETOF(struct vop_readlink_args,a_vp), 938 VDESC_NO_OFFSET 939 }; 940 const struct vnodeop_desc vop_readlink_desc = { 941 27, 942 "vop_readlink", 943 0, 944 vop_readlink_vp_offsets, 945 VDESC_NO_OFFSET, 946 VOPARG_OFFSETOF(struct vop_readlink_args, a_cred), 947 VDESC_NO_OFFSET, 948 VDESC_NO_OFFSET, 949 NULL, 950 }; 951 #ifdef VNODE_OP_NOINLINE 952 int 953 VOP_READLINK(vp, uio, cred) 954 struct vnode *vp; 955 struct uio *uio; 956 struct ucred *cred; 957 { 958 struct vop_readlink_args a; 959 a.a_desc = VDESC(vop_readlink); 960 a.a_vp = vp; 961 a.a_uio = uio; 962 a.a_cred = cred; 963 return (VCALL(vp, VOFFSET(vop_readlink), &a)); 964 } 965 #endif 966 967 const int vop_abortop_vp_offsets[] = { 968 VOPARG_OFFSETOF(struct vop_abortop_args,a_dvp), 969 VDESC_NO_OFFSET 970 }; 971 const struct vnodeop_desc vop_abortop_desc = { 972 28, 973 "vop_abortop", 974 0, 975 vop_abortop_vp_offsets, 976 VDESC_NO_OFFSET, 977 VDESC_NO_OFFSET, 978 VDESC_NO_OFFSET, 979 VOPARG_OFFSETOF(struct vop_abortop_args, a_cnp), 980 NULL, 981 }; 982 #ifdef VNODE_OP_NOINLINE 983 int 984 VOP_ABORTOP(dvp, cnp) 985 struct vnode *dvp; 986 struct componentname *cnp; 987 { 988 struct vop_abortop_args a; 989 a.a_desc = VDESC(vop_abortop); 990 a.a_dvp = dvp; 991 a.a_cnp = cnp; 992 return (VCALL(dvp, VOFFSET(vop_abortop), &a)); 993 } 994 #endif 995 996 const int vop_inactive_vp_offsets[] = { 997 VOPARG_OFFSETOF(struct vop_inactive_args,a_vp), 998 VDESC_NO_OFFSET 999 }; 1000 const struct vnodeop_desc vop_inactive_desc = { 1001 29, 1002 "vop_inactive", 1003 0 | VDESC_VP0_WILLUNLOCK, 1004 vop_inactive_vp_offsets, 1005 VDESC_NO_OFFSET, 1006 VDESC_NO_OFFSET, 1007 VOPARG_OFFSETOF(struct vop_inactive_args, a_p), 1008 VDESC_NO_OFFSET, 1009 NULL, 1010 }; 1011 #ifdef VNODE_OP_NOINLINE 1012 int 1013 VOP_INACTIVE(vp, p) 1014 struct vnode *vp; 1015 struct proc *p; 1016 { 1017 struct vop_inactive_args a; 1018 a.a_desc = VDESC(vop_inactive); 1019 a.a_vp = vp; 1020 a.a_p = p; 1021 return (VCALL(vp, VOFFSET(vop_inactive), &a)); 1022 } 1023 #endif 1024 1025 const int vop_reclaim_vp_offsets[] = { 1026 VOPARG_OFFSETOF(struct vop_reclaim_args,a_vp), 1027 VDESC_NO_OFFSET 1028 }; 1029 const struct vnodeop_desc vop_reclaim_desc = { 1030 30, 1031 "vop_reclaim", 1032 0, 1033 vop_reclaim_vp_offsets, 1034 VDESC_NO_OFFSET, 1035 VDESC_NO_OFFSET, 1036 VOPARG_OFFSETOF(struct vop_reclaim_args, a_p), 1037 VDESC_NO_OFFSET, 1038 NULL, 1039 }; 1040 #ifdef VNODE_OP_NOINLINE 1041 int 1042 VOP_RECLAIM(vp, p) 1043 struct vnode *vp; 1044 struct proc *p; 1045 { 1046 struct vop_reclaim_args a; 1047 a.a_desc = VDESC(vop_reclaim); 1048 a.a_vp = vp; 1049 a.a_p = p; 1050 return (VCALL(vp, VOFFSET(vop_reclaim), &a)); 1051 } 1052 #endif 1053 1054 const int vop_lock_vp_offsets[] = { 1055 VOPARG_OFFSETOF(struct vop_lock_args,a_vp), 1056 VDESC_NO_OFFSET 1057 }; 1058 const struct vnodeop_desc vop_lock_desc = { 1059 31, 1060 "vop_lock", 1061 0, 1062 vop_lock_vp_offsets, 1063 VDESC_NO_OFFSET, 1064 VDESC_NO_OFFSET, 1065 VDESC_NO_OFFSET, 1066 VDESC_NO_OFFSET, 1067 NULL, 1068 }; 1069 #ifdef VNODE_OP_NOINLINE 1070 int 1071 VOP_LOCK(vp, flags) 1072 struct vnode *vp; 1073 int flags; 1074 { 1075 struct vop_lock_args a; 1076 a.a_desc = VDESC(vop_lock); 1077 a.a_vp = vp; 1078 a.a_flags = flags; 1079 return (VCALL(vp, VOFFSET(vop_lock), &a)); 1080 } 1081 #endif 1082 1083 const int vop_unlock_vp_offsets[] = { 1084 VOPARG_OFFSETOF(struct vop_unlock_args,a_vp), 1085 VDESC_NO_OFFSET 1086 }; 1087 const struct vnodeop_desc vop_unlock_desc = { 1088 32, 1089 "vop_unlock", 1090 0, 1091 vop_unlock_vp_offsets, 1092 VDESC_NO_OFFSET, 1093 VDESC_NO_OFFSET, 1094 VDESC_NO_OFFSET, 1095 VDESC_NO_OFFSET, 1096 NULL, 1097 }; 1098 #ifdef VNODE_OP_NOINLINE 1099 int 1100 VOP_UNLOCK(vp, flags) 1101 struct vnode *vp; 1102 int flags; 1103 { 1104 struct vop_unlock_args a; 1105 a.a_desc = VDESC(vop_unlock); 1106 a.a_vp = vp; 1107 a.a_flags = flags; 1108 return (VCALL(vp, VOFFSET(vop_unlock), &a)); 1109 } 1110 #endif 1111 1112 const int vop_bmap_vp_offsets[] = { 1113 VOPARG_OFFSETOF(struct vop_bmap_args,a_vp), 1114 VDESC_NO_OFFSET 1115 }; 1116 const struct vnodeop_desc vop_bmap_desc = { 1117 33, 1118 "vop_bmap", 1119 0, 1120 vop_bmap_vp_offsets, 1121 VOPARG_OFFSETOF(struct vop_bmap_args, a_vpp), 1122 VDESC_NO_OFFSET, 1123 VDESC_NO_OFFSET, 1124 VDESC_NO_OFFSET, 1125 NULL, 1126 }; 1127 #ifdef VNODE_OP_NOINLINE 1128 int 1129 VOP_BMAP(vp, bn, vpp, bnp, runp) 1130 struct vnode *vp; 1131 daddr_t bn; 1132 struct vnode **vpp; 1133 daddr_t *bnp; 1134 int *runp; 1135 { 1136 struct vop_bmap_args a; 1137 a.a_desc = VDESC(vop_bmap); 1138 a.a_vp = vp; 1139 a.a_bn = bn; 1140 a.a_vpp = vpp; 1141 a.a_bnp = bnp; 1142 a.a_runp = runp; 1143 return (VCALL(vp, VOFFSET(vop_bmap), &a)); 1144 } 1145 #endif 1146 1147 const int vop_print_vp_offsets[] = { 1148 VOPARG_OFFSETOF(struct vop_print_args,a_vp), 1149 VDESC_NO_OFFSET 1150 }; 1151 const struct vnodeop_desc vop_print_desc = { 1152 34, 1153 "vop_print", 1154 0, 1155 vop_print_vp_offsets, 1156 VDESC_NO_OFFSET, 1157 VDESC_NO_OFFSET, 1158 VDESC_NO_OFFSET, 1159 VDESC_NO_OFFSET, 1160 NULL, 1161 }; 1162 #ifdef VNODE_OP_NOINLINE 1163 int 1164 VOP_PRINT(vp) 1165 struct vnode *vp; 1166 { 1167 struct vop_print_args a; 1168 a.a_desc = VDESC(vop_print); 1169 a.a_vp = vp; 1170 return (VCALL(vp, VOFFSET(vop_print), &a)); 1171 } 1172 #endif 1173 1174 const int vop_islocked_vp_offsets[] = { 1175 VOPARG_OFFSETOF(struct vop_islocked_args,a_vp), 1176 VDESC_NO_OFFSET 1177 }; 1178 const struct vnodeop_desc vop_islocked_desc = { 1179 35, 1180 "vop_islocked", 1181 0, 1182 vop_islocked_vp_offsets, 1183 VDESC_NO_OFFSET, 1184 VDESC_NO_OFFSET, 1185 VDESC_NO_OFFSET, 1186 VDESC_NO_OFFSET, 1187 NULL, 1188 }; 1189 #ifdef VNODE_OP_NOINLINE 1190 int 1191 VOP_ISLOCKED(vp) 1192 struct vnode *vp; 1193 { 1194 struct vop_islocked_args a; 1195 a.a_desc = VDESC(vop_islocked); 1196 a.a_vp = vp; 1197 return (VCALL(vp, VOFFSET(vop_islocked), &a)); 1198 } 1199 #endif 1200 1201 const int vop_pathconf_vp_offsets[] = { 1202 VOPARG_OFFSETOF(struct vop_pathconf_args,a_vp), 1203 VDESC_NO_OFFSET 1204 }; 1205 const struct vnodeop_desc vop_pathconf_desc = { 1206 36, 1207 "vop_pathconf", 1208 0, 1209 vop_pathconf_vp_offsets, 1210 VDESC_NO_OFFSET, 1211 VDESC_NO_OFFSET, 1212 VDESC_NO_OFFSET, 1213 VDESC_NO_OFFSET, 1214 NULL, 1215 }; 1216 #ifdef VNODE_OP_NOINLINE 1217 int 1218 VOP_PATHCONF(vp, name, retval) 1219 struct vnode *vp; 1220 int name; 1221 register_t *retval; 1222 { 1223 struct vop_pathconf_args a; 1224 a.a_desc = VDESC(vop_pathconf); 1225 a.a_vp = vp; 1226 a.a_name = name; 1227 a.a_retval = retval; 1228 return (VCALL(vp, VOFFSET(vop_pathconf), &a)); 1229 } 1230 #endif 1231 1232 const int vop_advlock_vp_offsets[] = { 1233 VOPARG_OFFSETOF(struct vop_advlock_args,a_vp), 1234 VDESC_NO_OFFSET 1235 }; 1236 const struct vnodeop_desc vop_advlock_desc = { 1237 37, 1238 "vop_advlock", 1239 0, 1240 vop_advlock_vp_offsets, 1241 VDESC_NO_OFFSET, 1242 VDESC_NO_OFFSET, 1243 VDESC_NO_OFFSET, 1244 VDESC_NO_OFFSET, 1245 NULL, 1246 }; 1247 #ifdef VNODE_OP_NOINLINE 1248 int 1249 VOP_ADVLOCK(vp, id, op, fl, flags) 1250 struct vnode *vp; 1251 caddr_t id; 1252 int op; 1253 struct flock *fl; 1254 int flags; 1255 { 1256 struct vop_advlock_args a; 1257 a.a_desc = VDESC(vop_advlock); 1258 a.a_vp = vp; 1259 a.a_id = id; 1260 a.a_op = op; 1261 a.a_fl = fl; 1262 a.a_flags = flags; 1263 return (VCALL(vp, VOFFSET(vop_advlock), &a)); 1264 } 1265 #endif 1266 1267 const int vop_blkatoff_vp_offsets[] = { 1268 VOPARG_OFFSETOF(struct vop_blkatoff_args,a_vp), 1269 VDESC_NO_OFFSET 1270 }; 1271 const struct vnodeop_desc vop_blkatoff_desc = { 1272 38, 1273 "vop_blkatoff", 1274 0, 1275 vop_blkatoff_vp_offsets, 1276 VDESC_NO_OFFSET, 1277 VDESC_NO_OFFSET, 1278 VDESC_NO_OFFSET, 1279 VDESC_NO_OFFSET, 1280 NULL, 1281 }; 1282 #ifdef VNODE_OP_NOINLINE 1283 int 1284 VOP_BLKATOFF(vp, offset, res, bpp) 1285 struct vnode *vp; 1286 off_t offset; 1287 char **res; 1288 struct buf **bpp; 1289 { 1290 struct vop_blkatoff_args a; 1291 a.a_desc = VDESC(vop_blkatoff); 1292 a.a_vp = vp; 1293 a.a_offset = offset; 1294 a.a_res = res; 1295 a.a_bpp = bpp; 1296 return (VCALL(vp, VOFFSET(vop_blkatoff), &a)); 1297 } 1298 #endif 1299 1300 const int vop_valloc_vp_offsets[] = { 1301 VOPARG_OFFSETOF(struct vop_valloc_args,a_pvp), 1302 VDESC_NO_OFFSET 1303 }; 1304 const struct vnodeop_desc vop_valloc_desc = { 1305 39, 1306 "vop_valloc", 1307 0, 1308 vop_valloc_vp_offsets, 1309 VOPARG_OFFSETOF(struct vop_valloc_args, a_vpp), 1310 VOPARG_OFFSETOF(struct vop_valloc_args, a_cred), 1311 VDESC_NO_OFFSET, 1312 VDESC_NO_OFFSET, 1313 NULL, 1314 }; 1315 #ifdef VNODE_OP_NOINLINE 1316 int 1317 VOP_VALLOC(pvp, mode, cred, vpp) 1318 struct vnode *pvp; 1319 int mode; 1320 struct ucred *cred; 1321 struct vnode **vpp; 1322 { 1323 struct vop_valloc_args a; 1324 a.a_desc = VDESC(vop_valloc); 1325 a.a_pvp = pvp; 1326 a.a_mode = mode; 1327 a.a_cred = cred; 1328 a.a_vpp = vpp; 1329 return (VCALL(pvp, VOFFSET(vop_valloc), &a)); 1330 } 1331 #endif 1332 1333 const int vop_balloc_vp_offsets[] = { 1334 VOPARG_OFFSETOF(struct vop_balloc_args,a_vp), 1335 VDESC_NO_OFFSET 1336 }; 1337 const struct vnodeop_desc vop_balloc_desc = { 1338 40, 1339 "vop_balloc", 1340 0, 1341 vop_balloc_vp_offsets, 1342 VDESC_NO_OFFSET, 1343 VOPARG_OFFSETOF(struct vop_balloc_args, a_cred), 1344 VDESC_NO_OFFSET, 1345 VDESC_NO_OFFSET, 1346 NULL, 1347 }; 1348 #ifdef VNODE_OP_NOINLINE 1349 int 1350 VOP_BALLOC(vp, startoffset, size, cred, flags, bpp) 1351 struct vnode *vp; 1352 off_t startoffset; 1353 int size; 1354 struct ucred *cred; 1355 int flags; 1356 struct buf **bpp; 1357 { 1358 struct vop_balloc_args a; 1359 a.a_desc = VDESC(vop_balloc); 1360 a.a_vp = vp; 1361 a.a_startoffset = startoffset; 1362 a.a_size = size; 1363 a.a_cred = cred; 1364 a.a_flags = flags; 1365 a.a_bpp = bpp; 1366 return (VCALL(vp, VOFFSET(vop_balloc), &a)); 1367 } 1368 #endif 1369 1370 const int vop_ballocn_vp_offsets[] = { 1371 VOPARG_OFFSETOF(struct vop_ballocn_args,a_vp), 1372 VDESC_NO_OFFSET 1373 }; 1374 const struct vnodeop_desc vop_ballocn_desc = { 1375 41, 1376 "vop_ballocn", 1377 0, 1378 vop_ballocn_vp_offsets, 1379 VDESC_NO_OFFSET, 1380 VOPARG_OFFSETOF(struct vop_ballocn_args, a_cred), 1381 VDESC_NO_OFFSET, 1382 VDESC_NO_OFFSET, 1383 NULL, 1384 }; 1385 #ifdef VNODE_OP_NOINLINE 1386 int 1387 VOP_BALLOCN(vp, offset, length, cred, flags) 1388 struct vnode *vp; 1389 off_t offset; 1390 off_t length; 1391 struct ucred *cred; 1392 int flags; 1393 { 1394 struct vop_ballocn_args a; 1395 a.a_desc = VDESC(vop_ballocn); 1396 a.a_vp = vp; 1397 a.a_offset = offset; 1398 a.a_length = length; 1399 a.a_cred = cred; 1400 a.a_flags = flags; 1401 return (VCALL(vp, VOFFSET(vop_ballocn), &a)); 1402 } 1403 #endif 1404 1405 const int vop_reallocblks_vp_offsets[] = { 1406 VOPARG_OFFSETOF(struct vop_reallocblks_args,a_vp), 1407 VDESC_NO_OFFSET 1408 }; 1409 const struct vnodeop_desc vop_reallocblks_desc = { 1410 42, 1411 "vop_reallocblks", 1412 0, 1413 vop_reallocblks_vp_offsets, 1414 VDESC_NO_OFFSET, 1415 VDESC_NO_OFFSET, 1416 VDESC_NO_OFFSET, 1417 VDESC_NO_OFFSET, 1418 NULL, 1419 }; 1420 #ifdef VNODE_OP_NOINLINE 1421 int 1422 VOP_REALLOCBLKS(vp, buflist) 1423 struct vnode *vp; 1424 struct cluster_save *buflist; 1425 { 1426 struct vop_reallocblks_args a; 1427 a.a_desc = VDESC(vop_reallocblks); 1428 a.a_vp = vp; 1429 a.a_buflist = buflist; 1430 return (VCALL(vp, VOFFSET(vop_reallocblks), &a)); 1431 } 1432 #endif 1433 1434 const int vop_vfree_vp_offsets[] = { 1435 VOPARG_OFFSETOF(struct vop_vfree_args,a_pvp), 1436 VDESC_NO_OFFSET 1437 }; 1438 const struct vnodeop_desc vop_vfree_desc = { 1439 43, 1440 "vop_vfree", 1441 0, 1442 vop_vfree_vp_offsets, 1443 VDESC_NO_OFFSET, 1444 VDESC_NO_OFFSET, 1445 VDESC_NO_OFFSET, 1446 VDESC_NO_OFFSET, 1447 NULL, 1448 }; 1449 #ifdef VNODE_OP_NOINLINE 1450 int 1451 VOP_VFREE(pvp, ino, mode) 1452 struct vnode *pvp; 1453 ino_t ino; 1454 int mode; 1455 { 1456 struct vop_vfree_args a; 1457 a.a_desc = VDESC(vop_vfree); 1458 a.a_pvp = pvp; 1459 a.a_ino = ino; 1460 a.a_mode = mode; 1461 return (VCALL(pvp, VOFFSET(vop_vfree), &a)); 1462 } 1463 #endif 1464 1465 const int vop_truncate_vp_offsets[] = { 1466 VOPARG_OFFSETOF(struct vop_truncate_args,a_vp), 1467 VDESC_NO_OFFSET 1468 }; 1469 const struct vnodeop_desc vop_truncate_desc = { 1470 44, 1471 "vop_truncate", 1472 0, 1473 vop_truncate_vp_offsets, 1474 VDESC_NO_OFFSET, 1475 VOPARG_OFFSETOF(struct vop_truncate_args, a_cred), 1476 VOPARG_OFFSETOF(struct vop_truncate_args, a_p), 1477 VDESC_NO_OFFSET, 1478 NULL, 1479 }; 1480 #ifdef VNODE_OP_NOINLINE 1481 int 1482 VOP_TRUNCATE(vp, length, flags, cred, p) 1483 struct vnode *vp; 1484 off_t length; 1485 int flags; 1486 struct ucred *cred; 1487 struct proc *p; 1488 { 1489 struct vop_truncate_args a; 1490 a.a_desc = VDESC(vop_truncate); 1491 a.a_vp = vp; 1492 a.a_length = length; 1493 a.a_flags = flags; 1494 a.a_cred = cred; 1495 a.a_p = p; 1496 return (VCALL(vp, VOFFSET(vop_truncate), &a)); 1497 } 1498 #endif 1499 1500 const int vop_update_vp_offsets[] = { 1501 VOPARG_OFFSETOF(struct vop_update_args,a_vp), 1502 VDESC_NO_OFFSET 1503 }; 1504 const struct vnodeop_desc vop_update_desc = { 1505 45, 1506 "vop_update", 1507 0, 1508 vop_update_vp_offsets, 1509 VDESC_NO_OFFSET, 1510 VDESC_NO_OFFSET, 1511 VDESC_NO_OFFSET, 1512 VDESC_NO_OFFSET, 1513 NULL, 1514 }; 1515 #ifdef VNODE_OP_NOINLINE 1516 int 1517 VOP_UPDATE(vp, access, modify, flags) 1518 struct vnode *vp; 1519 struct timespec *access; 1520 struct timespec *modify; 1521 int flags; 1522 { 1523 struct vop_update_args a; 1524 a.a_desc = VDESC(vop_update); 1525 a.a_vp = vp; 1526 a.a_access = access; 1527 a.a_modify = modify; 1528 a.a_flags = flags; 1529 return (VCALL(vp, VOFFSET(vop_update), &a)); 1530 } 1531 #endif 1532 1533 const int vop_lease_vp_offsets[] = { 1534 VOPARG_OFFSETOF(struct vop_lease_args,a_vp), 1535 VDESC_NO_OFFSET 1536 }; 1537 const struct vnodeop_desc vop_lease_desc = { 1538 46, 1539 "vop_lease", 1540 0, 1541 vop_lease_vp_offsets, 1542 VDESC_NO_OFFSET, 1543 VOPARG_OFFSETOF(struct vop_lease_args, a_cred), 1544 VOPARG_OFFSETOF(struct vop_lease_args, a_p), 1545 VDESC_NO_OFFSET, 1546 NULL, 1547 }; 1548 #ifdef VNODE_OP_NOINLINE 1549 int 1550 VOP_LEASE(vp, p, cred, flag) 1551 struct vnode *vp; 1552 struct proc *p; 1553 struct ucred *cred; 1554 int flag; 1555 { 1556 struct vop_lease_args a; 1557 a.a_desc = VDESC(vop_lease); 1558 a.a_vp = vp; 1559 a.a_p = p; 1560 a.a_cred = cred; 1561 a.a_flag = flag; 1562 return (VCALL(vp, VOFFSET(vop_lease), &a)); 1563 } 1564 #endif 1565 1566 const int vop_whiteout_vp_offsets[] = { 1567 VOPARG_OFFSETOF(struct vop_whiteout_args,a_dvp), 1568 VDESC_NO_OFFSET 1569 }; 1570 const struct vnodeop_desc vop_whiteout_desc = { 1571 47, 1572 "vop_whiteout", 1573 0, 1574 vop_whiteout_vp_offsets, 1575 VDESC_NO_OFFSET, 1576 VDESC_NO_OFFSET, 1577 VDESC_NO_OFFSET, 1578 VOPARG_OFFSETOF(struct vop_whiteout_args, a_cnp), 1579 NULL, 1580 }; 1581 #ifdef VNODE_OP_NOINLINE 1582 int 1583 VOP_WHITEOUT(dvp, cnp, flags) 1584 struct vnode *dvp; 1585 struct componentname *cnp; 1586 int flags; 1587 { 1588 struct vop_whiteout_args a; 1589 a.a_desc = VDESC(vop_whiteout); 1590 a.a_dvp = dvp; 1591 a.a_cnp = cnp; 1592 a.a_flags = flags; 1593 return (VCALL(dvp, VOFFSET(vop_whiteout), &a)); 1594 } 1595 #endif 1596 1597 const int vop_getpages_vp_offsets[] = { 1598 VOPARG_OFFSETOF(struct vop_getpages_args,a_vp), 1599 VDESC_NO_OFFSET 1600 }; 1601 const struct vnodeop_desc vop_getpages_desc = { 1602 48, 1603 "vop_getpages", 1604 0, 1605 vop_getpages_vp_offsets, 1606 VDESC_NO_OFFSET, 1607 VDESC_NO_OFFSET, 1608 VDESC_NO_OFFSET, 1609 VDESC_NO_OFFSET, 1610 NULL, 1611 }; 1612 #ifdef VNODE_OP_NOINLINE 1613 int 1614 VOP_GETPAGES(vp, offset, m, count, centeridx, access_type, advice, flags) 1615 struct vnode *vp; 1616 voff_t offset; 1617 vm_page_t *m; 1618 int *count; 1619 int centeridx; 1620 vm_prot_t access_type; 1621 int advice; 1622 int flags; 1623 { 1624 struct vop_getpages_args a; 1625 a.a_desc = VDESC(vop_getpages); 1626 a.a_vp = vp; 1627 a.a_offset = offset; 1628 a.a_m = m; 1629 a.a_count = count; 1630 a.a_centeridx = centeridx; 1631 a.a_access_type = access_type; 1632 a.a_advice = advice; 1633 a.a_flags = flags; 1634 return (VCALL(vp, VOFFSET(vop_getpages), &a)); 1635 } 1636 #endif 1637 1638 const int vop_putpages_vp_offsets[] = { 1639 VOPARG_OFFSETOF(struct vop_putpages_args,a_vp), 1640 VDESC_NO_OFFSET 1641 }; 1642 const struct vnodeop_desc vop_putpages_desc = { 1643 49, 1644 "vop_putpages", 1645 0, 1646 vop_putpages_vp_offsets, 1647 VDESC_NO_OFFSET, 1648 VDESC_NO_OFFSET, 1649 VDESC_NO_OFFSET, 1650 VDESC_NO_OFFSET, 1651 NULL, 1652 }; 1653 #ifdef VNODE_OP_NOINLINE 1654 int 1655 VOP_PUTPAGES(vp, m, count, flags, rtvals) 1656 struct vnode *vp; 1657 vm_page_t *m; 1658 int count; 1659 int flags; 1660 int *rtvals; 1661 { 1662 struct vop_putpages_args a; 1663 a.a_desc = VDESC(vop_putpages); 1664 a.a_vp = vp; 1665 a.a_m = m; 1666 a.a_count = count; 1667 a.a_flags = flags; 1668 a.a_rtvals = rtvals; 1669 return (VCALL(vp, VOFFSET(vop_putpages), &a)); 1670 } 1671 #endif 1672 1673 const int vop_size_vp_offsets[] = { 1674 VOPARG_OFFSETOF(struct vop_size_args,a_vp), 1675 VDESC_NO_OFFSET 1676 }; 1677 const struct vnodeop_desc vop_size_desc = { 1678 50, 1679 "vop_size", 1680 0, 1681 vop_size_vp_offsets, 1682 VDESC_NO_OFFSET, 1683 VDESC_NO_OFFSET, 1684 VDESC_NO_OFFSET, 1685 VDESC_NO_OFFSET, 1686 NULL, 1687 }; 1688 #ifdef VNODE_OP_NOINLINE 1689 int 1690 VOP_SIZE(vp, size, eobp) 1691 struct vnode *vp; 1692 off_t size; 1693 off_t *eobp; 1694 { 1695 struct vop_size_args a; 1696 a.a_desc = VDESC(vop_size); 1697 a.a_vp = vp; 1698 a.a_size = size; 1699 a.a_eobp = eobp; 1700 return (VCALL(vp, VOFFSET(vop_size), &a)); 1701 } 1702 #endif 1703 1704 /* End of special cases. */ 1705 1706 const struct vnodeop_desc * const vfs_op_descs[] = { 1707 &vop_default_desc, /* MUST BE FIRST */ 1708 &vop_strategy_desc, /* XXX: SPECIAL CASE */ 1709 &vop_bwrite_desc, /* XXX: SPECIAL CASE */ 1710 1711 &vop_lookup_desc, 1712 &vop_create_desc, 1713 &vop_mknod_desc, 1714 &vop_open_desc, 1715 &vop_close_desc, 1716 &vop_access_desc, 1717 &vop_getattr_desc, 1718 &vop_setattr_desc, 1719 &vop_read_desc, 1720 &vop_write_desc, 1721 &vop_ioctl_desc, 1722 &vop_fcntl_desc, 1723 &vop_poll_desc, 1724 &vop_revoke_desc, 1725 &vop_mmap_desc, 1726 &vop_fsync_desc, 1727 &vop_seek_desc, 1728 &vop_remove_desc, 1729 &vop_link_desc, 1730 &vop_rename_desc, 1731 &vop_mkdir_desc, 1732 &vop_rmdir_desc, 1733 &vop_symlink_desc, 1734 &vop_readdir_desc, 1735 &vop_readlink_desc, 1736 &vop_abortop_desc, 1737 &vop_inactive_desc, 1738 &vop_reclaim_desc, 1739 &vop_lock_desc, 1740 &vop_unlock_desc, 1741 &vop_bmap_desc, 1742 &vop_print_desc, 1743 &vop_islocked_desc, 1744 &vop_pathconf_desc, 1745 &vop_advlock_desc, 1746 &vop_blkatoff_desc, 1747 &vop_valloc_desc, 1748 &vop_balloc_desc, 1749 &vop_ballocn_desc, 1750 &vop_reallocblks_desc, 1751 &vop_vfree_desc, 1752 &vop_truncate_desc, 1753 &vop_update_desc, 1754 &vop_lease_desc, 1755 &vop_whiteout_desc, 1756 &vop_getpages_desc, 1757 &vop_putpages_desc, 1758 &vop_size_desc, 1759 NULL 1760 }; 1761 1762
Indexes created Sun Sep 21 16:09:51 GMT 2025