vnode_if.c revision 1.37.2.3
1 /* $NetBSD: vnode_if.c,v 1.37.2.3 2001/10/01 12:47:02 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_reallocblks_vp_offsets[] = { 1373 VOPARG_OFFSETOF(struct vop_reallocblks_args,a_vp), 1374 VDESC_NO_OFFSET 1375 }; 1376 const struct vnodeop_desc vop_reallocblks_desc = { 1377 41, 1378 "vop_reallocblks", 1379 0, 1380 vop_reallocblks_vp_offsets, 1381 VDESC_NO_OFFSET, 1382 VDESC_NO_OFFSET, 1383 VDESC_NO_OFFSET, 1384 VDESC_NO_OFFSET, 1385 NULL, 1386 }; 1387 #ifdef VNODE_OP_NOINLINE 1388 int 1389 VOP_REALLOCBLKS(vp, buflist) 1390 struct vnode *vp; 1391 struct cluster_save *buflist; 1392 { 1393 struct vop_reallocblks_args a; 1394 a.a_desc = VDESC(vop_reallocblks); 1395 a.a_vp = vp; 1396 a.a_buflist = buflist; 1397 return (VCALL(vp, VOFFSET(vop_reallocblks), &a)); 1398 } 1399 #endif 1400 1401 const int vop_vfree_vp_offsets[] = { 1402 VOPARG_OFFSETOF(struct vop_vfree_args,a_pvp), 1403 VDESC_NO_OFFSET 1404 }; 1405 const struct vnodeop_desc vop_vfree_desc = { 1406 42, 1407 "vop_vfree", 1408 0, 1409 vop_vfree_vp_offsets, 1410 VDESC_NO_OFFSET, 1411 VDESC_NO_OFFSET, 1412 VDESC_NO_OFFSET, 1413 VDESC_NO_OFFSET, 1414 NULL, 1415 }; 1416 #ifdef VNODE_OP_NOINLINE 1417 int 1418 VOP_VFREE(pvp, ino, mode) 1419 struct vnode *pvp; 1420 ino_t ino; 1421 int mode; 1422 { 1423 struct vop_vfree_args a; 1424 a.a_desc = VDESC(vop_vfree); 1425 a.a_pvp = pvp; 1426 a.a_ino = ino; 1427 a.a_mode = mode; 1428 return (VCALL(pvp, VOFFSET(vop_vfree), &a)); 1429 } 1430 #endif 1431 1432 const int vop_truncate_vp_offsets[] = { 1433 VOPARG_OFFSETOF(struct vop_truncate_args,a_vp), 1434 VDESC_NO_OFFSET 1435 }; 1436 const struct vnodeop_desc vop_truncate_desc = { 1437 43, 1438 "vop_truncate", 1439 0, 1440 vop_truncate_vp_offsets, 1441 VDESC_NO_OFFSET, 1442 VOPARG_OFFSETOF(struct vop_truncate_args, a_cred), 1443 VOPARG_OFFSETOF(struct vop_truncate_args, a_p), 1444 VDESC_NO_OFFSET, 1445 NULL, 1446 }; 1447 #ifdef VNODE_OP_NOINLINE 1448 int 1449 VOP_TRUNCATE(vp, length, flags, cred, p) 1450 struct vnode *vp; 1451 off_t length; 1452 int flags; 1453 struct ucred *cred; 1454 struct proc *p; 1455 { 1456 struct vop_truncate_args a; 1457 a.a_desc = VDESC(vop_truncate); 1458 a.a_vp = vp; 1459 a.a_length = length; 1460 a.a_flags = flags; 1461 a.a_cred = cred; 1462 a.a_p = p; 1463 return (VCALL(vp, VOFFSET(vop_truncate), &a)); 1464 } 1465 #endif 1466 1467 const int vop_update_vp_offsets[] = { 1468 VOPARG_OFFSETOF(struct vop_update_args,a_vp), 1469 VDESC_NO_OFFSET 1470 }; 1471 const struct vnodeop_desc vop_update_desc = { 1472 44, 1473 "vop_update", 1474 0, 1475 vop_update_vp_offsets, 1476 VDESC_NO_OFFSET, 1477 VDESC_NO_OFFSET, 1478 VDESC_NO_OFFSET, 1479 VDESC_NO_OFFSET, 1480 NULL, 1481 }; 1482 #ifdef VNODE_OP_NOINLINE 1483 int 1484 VOP_UPDATE(vp, access, modify, flags) 1485 struct vnode *vp; 1486 struct timespec *access; 1487 struct timespec *modify; 1488 int flags; 1489 { 1490 struct vop_update_args a; 1491 a.a_desc = VDESC(vop_update); 1492 a.a_vp = vp; 1493 a.a_access = access; 1494 a.a_modify = modify; 1495 a.a_flags = flags; 1496 return (VCALL(vp, VOFFSET(vop_update), &a)); 1497 } 1498 #endif 1499 1500 const int vop_lease_vp_offsets[] = { 1501 VOPARG_OFFSETOF(struct vop_lease_args,a_vp), 1502 VDESC_NO_OFFSET 1503 }; 1504 const struct vnodeop_desc vop_lease_desc = { 1505 45, 1506 "vop_lease", 1507 0, 1508 vop_lease_vp_offsets, 1509 VDESC_NO_OFFSET, 1510 VOPARG_OFFSETOF(struct vop_lease_args, a_cred), 1511 VOPARG_OFFSETOF(struct vop_lease_args, a_p), 1512 VDESC_NO_OFFSET, 1513 NULL, 1514 }; 1515 #ifdef VNODE_OP_NOINLINE 1516 int 1517 VOP_LEASE(vp, p, cred, flag) 1518 struct vnode *vp; 1519 struct proc *p; 1520 struct ucred *cred; 1521 int flag; 1522 { 1523 struct vop_lease_args a; 1524 a.a_desc = VDESC(vop_lease); 1525 a.a_vp = vp; 1526 a.a_p = p; 1527 a.a_cred = cred; 1528 a.a_flag = flag; 1529 return (VCALL(vp, VOFFSET(vop_lease), &a)); 1530 } 1531 #endif 1532 1533 const int vop_whiteout_vp_offsets[] = { 1534 VOPARG_OFFSETOF(struct vop_whiteout_args,a_dvp), 1535 VDESC_NO_OFFSET 1536 }; 1537 const struct vnodeop_desc vop_whiteout_desc = { 1538 46, 1539 "vop_whiteout", 1540 0, 1541 vop_whiteout_vp_offsets, 1542 VDESC_NO_OFFSET, 1543 VDESC_NO_OFFSET, 1544 VDESC_NO_OFFSET, 1545 VOPARG_OFFSETOF(struct vop_whiteout_args, a_cnp), 1546 NULL, 1547 }; 1548 #ifdef VNODE_OP_NOINLINE 1549 int 1550 VOP_WHITEOUT(dvp, cnp, flags) 1551 struct vnode *dvp; 1552 struct componentname *cnp; 1553 int flags; 1554 { 1555 struct vop_whiteout_args a; 1556 a.a_desc = VDESC(vop_whiteout); 1557 a.a_dvp = dvp; 1558 a.a_cnp = cnp; 1559 a.a_flags = flags; 1560 return (VCALL(dvp, VOFFSET(vop_whiteout), &a)); 1561 } 1562 #endif 1563 1564 const int vop_getpages_vp_offsets[] = { 1565 VOPARG_OFFSETOF(struct vop_getpages_args,a_vp), 1566 VDESC_NO_OFFSET 1567 }; 1568 const struct vnodeop_desc vop_getpages_desc = { 1569 47, 1570 "vop_getpages", 1571 0, 1572 vop_getpages_vp_offsets, 1573 VDESC_NO_OFFSET, 1574 VDESC_NO_OFFSET, 1575 VDESC_NO_OFFSET, 1576 VDESC_NO_OFFSET, 1577 NULL, 1578 }; 1579 #ifdef VNODE_OP_NOINLINE 1580 int 1581 VOP_GETPAGES(vp, offset, m, count, centeridx, access_type, advice, flags) 1582 struct vnode *vp; 1583 voff_t offset; 1584 struct vm_page **m; 1585 int *count; 1586 int centeridx; 1587 vm_prot_t access_type; 1588 int advice; 1589 int flags; 1590 { 1591 struct vop_getpages_args a; 1592 a.a_desc = VDESC(vop_getpages); 1593 a.a_vp = vp; 1594 a.a_offset = offset; 1595 a.a_m = m; 1596 a.a_count = count; 1597 a.a_centeridx = centeridx; 1598 a.a_access_type = access_type; 1599 a.a_advice = advice; 1600 a.a_flags = flags; 1601 return (VCALL(vp, VOFFSET(vop_getpages), &a)); 1602 } 1603 #endif 1604 1605 const int vop_putpages_vp_offsets[] = { 1606 VOPARG_OFFSETOF(struct vop_putpages_args,a_vp), 1607 VDESC_NO_OFFSET 1608 }; 1609 const struct vnodeop_desc vop_putpages_desc = { 1610 48, 1611 "vop_putpages", 1612 0, 1613 vop_putpages_vp_offsets, 1614 VDESC_NO_OFFSET, 1615 VDESC_NO_OFFSET, 1616 VDESC_NO_OFFSET, 1617 VDESC_NO_OFFSET, 1618 NULL, 1619 }; 1620 #ifdef VNODE_OP_NOINLINE 1621 int 1622 VOP_PUTPAGES(vp, offlo, offhi, flags) 1623 struct vnode *vp; 1624 voff_t offlo; 1625 voff_t offhi; 1626 int flags; 1627 { 1628 struct vop_putpages_args a; 1629 a.a_desc = VDESC(vop_putpages); 1630 a.a_vp = vp; 1631 a.a_offlo = offlo; 1632 a.a_offhi = offhi; 1633 a.a_flags = flags; 1634 return (VCALL(vp, VOFFSET(vop_putpages), &a)); 1635 } 1636 #endif 1637 1638 /* End of special cases. */ 1639 1640 const struct vnodeop_desc * const vfs_op_descs[] = { 1641 &vop_default_desc, /* MUST BE FIRST */ 1642 &vop_strategy_desc, /* XXX: SPECIAL CASE */ 1643 &vop_bwrite_desc, /* XXX: SPECIAL CASE */ 1644 1645 &vop_lookup_desc, 1646 &vop_create_desc, 1647 &vop_mknod_desc, 1648 &vop_open_desc, 1649 &vop_close_desc, 1650 &vop_access_desc, 1651 &vop_getattr_desc, 1652 &vop_setattr_desc, 1653 &vop_read_desc, 1654 &vop_write_desc, 1655 &vop_ioctl_desc, 1656 &vop_fcntl_desc, 1657 &vop_poll_desc, 1658 &vop_revoke_desc, 1659 &vop_mmap_desc, 1660 &vop_fsync_desc, 1661 &vop_seek_desc, 1662 &vop_remove_desc, 1663 &vop_link_desc, 1664 &vop_rename_desc, 1665 &vop_mkdir_desc, 1666 &vop_rmdir_desc, 1667 &vop_symlink_desc, 1668 &vop_readdir_desc, 1669 &vop_readlink_desc, 1670 &vop_abortop_desc, 1671 &vop_inactive_desc, 1672 &vop_reclaim_desc, 1673 &vop_lock_desc, 1674 &vop_unlock_desc, 1675 &vop_bmap_desc, 1676 &vop_print_desc, 1677 &vop_islocked_desc, 1678 &vop_pathconf_desc, 1679 &vop_advlock_desc, 1680 &vop_blkatoff_desc, 1681 &vop_valloc_desc, 1682 &vop_balloc_desc, 1683 &vop_reallocblks_desc, 1684 &vop_vfree_desc, 1685 &vop_truncate_desc, 1686 &vop_update_desc, 1687 &vop_lease_desc, 1688 &vop_whiteout_desc, 1689 &vop_getpages_desc, 1690 &vop_putpages_desc, 1691 NULL 1692 }; 1693 1694
Indexes created Tue Sep 30 20:09:53 GMT 2025