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