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