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