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