1 /* $NetBSD: vnode_if.c,v 1.40 2002/10/23 09:16:46 jdolecek 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.31 2002/10/23 09:14:32 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. 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.40 2002/10/23 09:16:46 jdolecek 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_kqfilter_vp_offsets[] = { 568 VOPARG_OFFSETOF(struct vop_kqfilter_args,a_vp), 569 VDESC_NO_OFFSET 570 }; 571 const struct vnodeop_desc vop_kqfilter_desc = { 572 16, 573 "vop_kqfilter", 574 0, 575 vop_kqfilter_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_KQFILTER(vp, kn) 585 struct vnode *vp; 586 struct knote *kn; 587 { 588 struct vop_kqfilter_args a; 589 a.a_desc = VDESC(vop_kqfilter); 590 a.a_vp = vp; 591 a.a_kn = kn; 592 return (VCALL(vp, VOFFSET(vop_kqfilter), &a)); 593 } 594 #endif 595 596 const int vop_revoke_vp_offsets[] = { 597 VOPARG_OFFSETOF(struct vop_revoke_args,a_vp), 598 VDESC_NO_OFFSET 599 }; 600 const struct vnodeop_desc vop_revoke_desc = { 601 17, 602 "vop_revoke", 603 0, 604 vop_revoke_vp_offsets, 605 VDESC_NO_OFFSET, 606 VDESC_NO_OFFSET, 607 VDESC_NO_OFFSET, 608 VDESC_NO_OFFSET, 609 NULL, 610 }; 611 #ifdef VNODE_OP_NOINLINE 612 int 613 VOP_REVOKE(vp, flags) 614 struct vnode *vp; 615 int flags; 616 { 617 struct vop_revoke_args a; 618 a.a_desc = VDESC(vop_revoke); 619 a.a_vp = vp; 620 a.a_flags = flags; 621 return (VCALL(vp, VOFFSET(vop_revoke), &a)); 622 } 623 #endif 624 625 const int vop_mmap_vp_offsets[] = { 626 VOPARG_OFFSETOF(struct vop_mmap_args,a_vp), 627 VDESC_NO_OFFSET 628 }; 629 const struct vnodeop_desc vop_mmap_desc = { 630 18, 631 "vop_mmap", 632 0, 633 vop_mmap_vp_offsets, 634 VDESC_NO_OFFSET, 635 VOPARG_OFFSETOF(struct vop_mmap_args, a_cred), 636 VOPARG_OFFSETOF(struct vop_mmap_args, a_p), 637 VDESC_NO_OFFSET, 638 NULL, 639 }; 640 #ifdef VNODE_OP_NOINLINE 641 int 642 VOP_MMAP(vp, fflags, cred, p) 643 struct vnode *vp; 644 int fflags; 645 struct ucred *cred; 646 struct proc *p; 647 { 648 struct vop_mmap_args a; 649 a.a_desc = VDESC(vop_mmap); 650 a.a_vp = vp; 651 a.a_fflags = fflags; 652 a.a_cred = cred; 653 a.a_p = p; 654 return (VCALL(vp, VOFFSET(vop_mmap), &a)); 655 } 656 #endif 657 658 const int vop_fsync_vp_offsets[] = { 659 VOPARG_OFFSETOF(struct vop_fsync_args,a_vp), 660 VDESC_NO_OFFSET 661 }; 662 const struct vnodeop_desc vop_fsync_desc = { 663 19, 664 "vop_fsync", 665 0, 666 vop_fsync_vp_offsets, 667 VDESC_NO_OFFSET, 668 VOPARG_OFFSETOF(struct vop_fsync_args, a_cred), 669 VOPARG_OFFSETOF(struct vop_fsync_args, a_p), 670 VDESC_NO_OFFSET, 671 NULL, 672 }; 673 #ifdef VNODE_OP_NOINLINE 674 int 675 VOP_FSYNC(vp, cred, flags, offlo, offhi, p) 676 struct vnode *vp; 677 struct ucred *cred; 678 int flags; 679 off_t offlo; 680 off_t offhi; 681 struct proc *p; 682 { 683 struct vop_fsync_args a; 684 a.a_desc = VDESC(vop_fsync); 685 a.a_vp = vp; 686 a.a_cred = cred; 687 a.a_flags = flags; 688 a.a_offlo = offlo; 689 a.a_offhi = offhi; 690 a.a_p = p; 691 return (VCALL(vp, VOFFSET(vop_fsync), &a)); 692 } 693 #endif 694 695 const int vop_seek_vp_offsets[] = { 696 VOPARG_OFFSETOF(struct vop_seek_args,a_vp), 697 VDESC_NO_OFFSET 698 }; 699 const struct vnodeop_desc vop_seek_desc = { 700 20, 701 "vop_seek", 702 0, 703 vop_seek_vp_offsets, 704 VDESC_NO_OFFSET, 705 VOPARG_OFFSETOF(struct vop_seek_args, a_cred), 706 VDESC_NO_OFFSET, 707 VDESC_NO_OFFSET, 708 NULL, 709 }; 710 #ifdef VNODE_OP_NOINLINE 711 int 712 VOP_SEEK(vp, oldoff, newoff, cred) 713 struct vnode *vp; 714 off_t oldoff; 715 off_t newoff; 716 struct ucred *cred; 717 { 718 struct vop_seek_args a; 719 a.a_desc = VDESC(vop_seek); 720 a.a_vp = vp; 721 a.a_oldoff = oldoff; 722 a.a_newoff = newoff; 723 a.a_cred = cred; 724 return (VCALL(vp, VOFFSET(vop_seek), &a)); 725 } 726 #endif 727 728 const int vop_remove_vp_offsets[] = { 729 VOPARG_OFFSETOF(struct vop_remove_args,a_dvp), 730 VOPARG_OFFSETOF(struct vop_remove_args,a_vp), 731 VDESC_NO_OFFSET 732 }; 733 const struct vnodeop_desc vop_remove_desc = { 734 21, 735 "vop_remove", 736 0 | VDESC_VP0_WILLPUT | VDESC_VP1_WILLPUT, 737 vop_remove_vp_offsets, 738 VDESC_NO_OFFSET, 739 VDESC_NO_OFFSET, 740 VDESC_NO_OFFSET, 741 VOPARG_OFFSETOF(struct vop_remove_args, a_cnp), 742 NULL, 743 }; 744 #ifdef VNODE_OP_NOINLINE 745 int 746 VOP_REMOVE(dvp, vp, cnp) 747 struct vnode *dvp; 748 struct vnode *vp; 749 struct componentname *cnp; 750 { 751 struct vop_remove_args a; 752 a.a_desc = VDESC(vop_remove); 753 a.a_dvp = dvp; 754 a.a_vp = vp; 755 a.a_cnp = cnp; 756 return (VCALL(dvp, VOFFSET(vop_remove), &a)); 757 } 758 #endif 759 760 const int vop_link_vp_offsets[] = { 761 VOPARG_OFFSETOF(struct vop_link_args,a_dvp), 762 VOPARG_OFFSETOF(struct vop_link_args,a_vp), 763 VDESC_NO_OFFSET 764 }; 765 const struct vnodeop_desc vop_link_desc = { 766 22, 767 "vop_link", 768 0 | VDESC_VP0_WILLPUT, 769 vop_link_vp_offsets, 770 VDESC_NO_OFFSET, 771 VDESC_NO_OFFSET, 772 VDESC_NO_OFFSET, 773 VOPARG_OFFSETOF(struct vop_link_args, a_cnp), 774 NULL, 775 }; 776 #ifdef VNODE_OP_NOINLINE 777 int 778 VOP_LINK(dvp, vp, cnp) 779 struct vnode *dvp; 780 struct vnode *vp; 781 struct componentname *cnp; 782 { 783 struct vop_link_args a; 784 a.a_desc = VDESC(vop_link); 785 a.a_dvp = dvp; 786 a.a_vp = vp; 787 a.a_cnp = cnp; 788 return (VCALL(dvp, VOFFSET(vop_link), &a)); 789 } 790 #endif 791 792 const int vop_rename_vp_offsets[] = { 793 VOPARG_OFFSETOF(struct vop_rename_args,a_fdvp), 794 VOPARG_OFFSETOF(struct vop_rename_args,a_fvp), 795 VOPARG_OFFSETOF(struct vop_rename_args,a_tdvp), 796 VOPARG_OFFSETOF(struct vop_rename_args,a_tvp), 797 VDESC_NO_OFFSET 798 }; 799 const struct vnodeop_desc vop_rename_desc = { 800 23, 801 "vop_rename", 802 0 | VDESC_VP0_WILLRELE | VDESC_VP1_WILLRELE | VDESC_VP2_WILLPUT | VDESC_VP3_WILLRELE, 803 vop_rename_vp_offsets, 804 VDESC_NO_OFFSET, 805 VDESC_NO_OFFSET, 806 VDESC_NO_OFFSET, 807 VOPARG_OFFSETOF(struct vop_rename_args, a_fcnp), 808 NULL, 809 }; 810 #ifdef VNODE_OP_NOINLINE 811 int 812 VOP_RENAME(fdvp, fvp, fcnp, tdvp, tvp, tcnp) 813 struct vnode *fdvp; 814 struct vnode *fvp; 815 struct componentname *fcnp; 816 struct vnode *tdvp; 817 struct vnode *tvp; 818 struct componentname *tcnp; 819 { 820 struct vop_rename_args a; 821 a.a_desc = VDESC(vop_rename); 822 a.a_fdvp = fdvp; 823 a.a_fvp = fvp; 824 a.a_fcnp = fcnp; 825 a.a_tdvp = tdvp; 826 a.a_tvp = tvp; 827 a.a_tcnp = tcnp; 828 return (VCALL(fdvp, VOFFSET(vop_rename), &a)); 829 } 830 #endif 831 832 const int vop_mkdir_vp_offsets[] = { 833 VOPARG_OFFSETOF(struct vop_mkdir_args,a_dvp), 834 VDESC_NO_OFFSET 835 }; 836 const struct vnodeop_desc vop_mkdir_desc = { 837 24, 838 "vop_mkdir", 839 0 | VDESC_VP0_WILLPUT, 840 vop_mkdir_vp_offsets, 841 VOPARG_OFFSETOF(struct vop_mkdir_args, a_vpp), 842 VDESC_NO_OFFSET, 843 VDESC_NO_OFFSET, 844 VOPARG_OFFSETOF(struct vop_mkdir_args, a_cnp), 845 NULL, 846 }; 847 #ifdef VNODE_OP_NOINLINE 848 int 849 VOP_MKDIR(dvp, vpp, cnp, vap) 850 struct vnode *dvp; 851 struct vnode **vpp; 852 struct componentname *cnp; 853 struct vattr *vap; 854 { 855 struct vop_mkdir_args a; 856 a.a_desc = VDESC(vop_mkdir); 857 a.a_dvp = dvp; 858 a.a_vpp = vpp; 859 a.a_cnp = cnp; 860 a.a_vap = vap; 861 return (VCALL(dvp, VOFFSET(vop_mkdir), &a)); 862 } 863 #endif 864 865 const int vop_rmdir_vp_offsets[] = { 866 VOPARG_OFFSETOF(struct vop_rmdir_args,a_dvp), 867 VOPARG_OFFSETOF(struct vop_rmdir_args,a_vp), 868 VDESC_NO_OFFSET 869 }; 870 const struct vnodeop_desc vop_rmdir_desc = { 871 25, 872 "vop_rmdir", 873 0 | VDESC_VP0_WILLPUT | VDESC_VP1_WILLPUT, 874 vop_rmdir_vp_offsets, 875 VDESC_NO_OFFSET, 876 VDESC_NO_OFFSET, 877 VDESC_NO_OFFSET, 878 VOPARG_OFFSETOF(struct vop_rmdir_args, a_cnp), 879 NULL, 880 }; 881 #ifdef VNODE_OP_NOINLINE 882 int 883 VOP_RMDIR(dvp, vp, cnp) 884 struct vnode *dvp; 885 struct vnode *vp; 886 struct componentname *cnp; 887 { 888 struct vop_rmdir_args a; 889 a.a_desc = VDESC(vop_rmdir); 890 a.a_dvp = dvp; 891 a.a_vp = vp; 892 a.a_cnp = cnp; 893 return (VCALL(dvp, VOFFSET(vop_rmdir), &a)); 894 } 895 #endif 896 897 const int vop_symlink_vp_offsets[] = { 898 VOPARG_OFFSETOF(struct vop_symlink_args,a_dvp), 899 VDESC_NO_OFFSET 900 }; 901 const struct vnodeop_desc vop_symlink_desc = { 902 26, 903 "vop_symlink", 904 0 | VDESC_VP0_WILLPUT, 905 vop_symlink_vp_offsets, 906 VOPARG_OFFSETOF(struct vop_symlink_args, a_vpp), 907 VDESC_NO_OFFSET, 908 VDESC_NO_OFFSET, 909 VOPARG_OFFSETOF(struct vop_symlink_args, a_cnp), 910 NULL, 911 }; 912 #ifdef VNODE_OP_NOINLINE 913 int 914 VOP_SYMLINK(dvp, vpp, cnp, vap, target) 915 struct vnode *dvp; 916 struct vnode **vpp; 917 struct componentname *cnp; 918 struct vattr *vap; 919 char *target; 920 { 921 struct vop_symlink_args a; 922 a.a_desc = VDESC(vop_symlink); 923 a.a_dvp = dvp; 924 a.a_vpp = vpp; 925 a.a_cnp = cnp; 926 a.a_vap = vap; 927 a.a_target = target; 928 return (VCALL(dvp, VOFFSET(vop_symlink), &a)); 929 } 930 #endif 931 932 const int vop_readdir_vp_offsets[] = { 933 VOPARG_OFFSETOF(struct vop_readdir_args,a_vp), 934 VDESC_NO_OFFSET 935 }; 936 const struct vnodeop_desc vop_readdir_desc = { 937 27, 938 "vop_readdir", 939 0, 940 vop_readdir_vp_offsets, 941 VDESC_NO_OFFSET, 942 VOPARG_OFFSETOF(struct vop_readdir_args, a_cred), 943 VDESC_NO_OFFSET, 944 VDESC_NO_OFFSET, 945 NULL, 946 }; 947 #ifdef VNODE_OP_NOINLINE 948 int 949 VOP_READDIR(vp, uio, cred, eofflag, cookies, ncookies) 950 struct vnode *vp; 951 struct uio *uio; 952 struct ucred *cred; 953 int *eofflag; 954 off_t **cookies; 955 int *ncookies; 956 { 957 struct vop_readdir_args a; 958 a.a_desc = VDESC(vop_readdir); 959 a.a_vp = vp; 960 a.a_uio = uio; 961 a.a_cred = cred; 962 a.a_eofflag = eofflag; 963 a.a_cookies = cookies; 964 a.a_ncookies = ncookies; 965 return (VCALL(vp, VOFFSET(vop_readdir), &a)); 966 } 967 #endif 968 969 const int vop_readlink_vp_offsets[] = { 970 VOPARG_OFFSETOF(struct vop_readlink_args,a_vp), 971 VDESC_NO_OFFSET 972 }; 973 const struct vnodeop_desc vop_readlink_desc = { 974 28, 975 "vop_readlink", 976 0, 977 vop_readlink_vp_offsets, 978 VDESC_NO_OFFSET, 979 VOPARG_OFFSETOF(struct vop_readlink_args, a_cred), 980 VDESC_NO_OFFSET, 981 VDESC_NO_OFFSET, 982 NULL, 983 }; 984 #ifdef VNODE_OP_NOINLINE 985 int 986 VOP_READLINK(vp, uio, cred) 987 struct vnode *vp; 988 struct uio *uio; 989 struct ucred *cred; 990 { 991 struct vop_readlink_args a; 992 a.a_desc = VDESC(vop_readlink); 993 a.a_vp = vp; 994 a.a_uio = uio; 995 a.a_cred = cred; 996 return (VCALL(vp, VOFFSET(vop_readlink), &a)); 997 } 998 #endif 999 1000 const int vop_abortop_vp_offsets[] = { 1001 VOPARG_OFFSETOF(struct vop_abortop_args,a_dvp), 1002 VDESC_NO_OFFSET 1003 }; 1004 const struct vnodeop_desc vop_abortop_desc = { 1005 29, 1006 "vop_abortop", 1007 0, 1008 vop_abortop_vp_offsets, 1009 VDESC_NO_OFFSET, 1010 VDESC_NO_OFFSET, 1011 VDESC_NO_OFFSET, 1012 VOPARG_OFFSETOF(struct vop_abortop_args, a_cnp), 1013 NULL, 1014 }; 1015 #ifdef VNODE_OP_NOINLINE 1016 int 1017 VOP_ABORTOP(dvp, cnp) 1018 struct vnode *dvp; 1019 struct componentname *cnp; 1020 { 1021 struct vop_abortop_args a; 1022 a.a_desc = VDESC(vop_abortop); 1023 a.a_dvp = dvp; 1024 a.a_cnp = cnp; 1025 return (VCALL(dvp, VOFFSET(vop_abortop), &a)); 1026 } 1027 #endif 1028 1029 const int vop_inactive_vp_offsets[] = { 1030 VOPARG_OFFSETOF(struct vop_inactive_args,a_vp), 1031 VDESC_NO_OFFSET 1032 }; 1033 const struct vnodeop_desc vop_inactive_desc = { 1034 30, 1035 "vop_inactive", 1036 0 | VDESC_VP0_WILLUNLOCK, 1037 vop_inactive_vp_offsets, 1038 VDESC_NO_OFFSET, 1039 VDESC_NO_OFFSET, 1040 VOPARG_OFFSETOF(struct vop_inactive_args, a_p), 1041 VDESC_NO_OFFSET, 1042 NULL, 1043 }; 1044 #ifdef VNODE_OP_NOINLINE 1045 int 1046 VOP_INACTIVE(vp, p) 1047 struct vnode *vp; 1048 struct proc *p; 1049 { 1050 struct vop_inactive_args a; 1051 a.a_desc = VDESC(vop_inactive); 1052 a.a_vp = vp; 1053 a.a_p = p; 1054 return (VCALL(vp, VOFFSET(vop_inactive), &a)); 1055 } 1056 #endif 1057 1058 const int vop_reclaim_vp_offsets[] = { 1059 VOPARG_OFFSETOF(struct vop_reclaim_args,a_vp), 1060 VDESC_NO_OFFSET 1061 }; 1062 const struct vnodeop_desc vop_reclaim_desc = { 1063 31, 1064 "vop_reclaim", 1065 0, 1066 vop_reclaim_vp_offsets, 1067 VDESC_NO_OFFSET, 1068 VDESC_NO_OFFSET, 1069 VOPARG_OFFSETOF(struct vop_reclaim_args, a_p), 1070 VDESC_NO_OFFSET, 1071 NULL, 1072 }; 1073 #ifdef VNODE_OP_NOINLINE 1074 int 1075 VOP_RECLAIM(vp, p) 1076 struct vnode *vp; 1077 struct proc *p; 1078 { 1079 struct vop_reclaim_args a; 1080 a.a_desc = VDESC(vop_reclaim); 1081 a.a_vp = vp; 1082 a.a_p = p; 1083 return (VCALL(vp, VOFFSET(vop_reclaim), &a)); 1084 } 1085 #endif 1086 1087 const int vop_lock_vp_offsets[] = { 1088 VOPARG_OFFSETOF(struct vop_lock_args,a_vp), 1089 VDESC_NO_OFFSET 1090 }; 1091 const struct vnodeop_desc vop_lock_desc = { 1092 32, 1093 "vop_lock", 1094 0, 1095 vop_lock_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_LOCK(vp, flags) 1105 struct vnode *vp; 1106 int flags; 1107 { 1108 struct vop_lock_args a; 1109 a.a_desc = VDESC(vop_lock); 1110 a.a_vp = vp; 1111 a.a_flags = flags; 1112 return (VCALL(vp, VOFFSET(vop_lock), &a)); 1113 } 1114 #endif 1115 1116 const int vop_unlock_vp_offsets[] = { 1117 VOPARG_OFFSETOF(struct vop_unlock_args,a_vp), 1118 VDESC_NO_OFFSET 1119 }; 1120 const struct vnodeop_desc vop_unlock_desc = { 1121 33, 1122 "vop_unlock", 1123 0, 1124 vop_unlock_vp_offsets, 1125 VDESC_NO_OFFSET, 1126 VDESC_NO_OFFSET, 1127 VDESC_NO_OFFSET, 1128 VDESC_NO_OFFSET, 1129 NULL, 1130 }; 1131 #ifdef VNODE_OP_NOINLINE 1132 int 1133 VOP_UNLOCK(vp, flags) 1134 struct vnode *vp; 1135 int flags; 1136 { 1137 struct vop_unlock_args a; 1138 a.a_desc = VDESC(vop_unlock); 1139 a.a_vp = vp; 1140 a.a_flags = flags; 1141 return (VCALL(vp, VOFFSET(vop_unlock), &a)); 1142 } 1143 #endif 1144 1145 const int vop_bmap_vp_offsets[] = { 1146 VOPARG_OFFSETOF(struct vop_bmap_args,a_vp), 1147 VDESC_NO_OFFSET 1148 }; 1149 const struct vnodeop_desc vop_bmap_desc = { 1150 34, 1151 "vop_bmap", 1152 0, 1153 vop_bmap_vp_offsets, 1154 VOPARG_OFFSETOF(struct vop_bmap_args, a_vpp), 1155 VDESC_NO_OFFSET, 1156 VDESC_NO_OFFSET, 1157 VDESC_NO_OFFSET, 1158 NULL, 1159 }; 1160 #ifdef VNODE_OP_NOINLINE 1161 int 1162 VOP_BMAP(vp, bn, vpp, bnp, runp) 1163 struct vnode *vp; 1164 daddr_t bn; 1165 struct vnode **vpp; 1166 daddr_t *bnp; 1167 int *runp; 1168 { 1169 struct vop_bmap_args a; 1170 a.a_desc = VDESC(vop_bmap); 1171 a.a_vp = vp; 1172 a.a_bn = bn; 1173 a.a_vpp = vpp; 1174 a.a_bnp = bnp; 1175 a.a_runp = runp; 1176 return (VCALL(vp, VOFFSET(vop_bmap), &a)); 1177 } 1178 #endif 1179 1180 const int vop_print_vp_offsets[] = { 1181 VOPARG_OFFSETOF(struct vop_print_args,a_vp), 1182 VDESC_NO_OFFSET 1183 }; 1184 const struct vnodeop_desc vop_print_desc = { 1185 35, 1186 "vop_print", 1187 0, 1188 vop_print_vp_offsets, 1189 VDESC_NO_OFFSET, 1190 VDESC_NO_OFFSET, 1191 VDESC_NO_OFFSET, 1192 VDESC_NO_OFFSET, 1193 NULL, 1194 }; 1195 #ifdef VNODE_OP_NOINLINE 1196 int 1197 VOP_PRINT(vp) 1198 struct vnode *vp; 1199 { 1200 struct vop_print_args a; 1201 a.a_desc = VDESC(vop_print); 1202 a.a_vp = vp; 1203 return (VCALL(vp, VOFFSET(vop_print), &a)); 1204 } 1205 #endif 1206 1207 const int vop_islocked_vp_offsets[] = { 1208 VOPARG_OFFSETOF(struct vop_islocked_args,a_vp), 1209 VDESC_NO_OFFSET 1210 }; 1211 const struct vnodeop_desc vop_islocked_desc = { 1212 36, 1213 "vop_islocked", 1214 0, 1215 vop_islocked_vp_offsets, 1216 VDESC_NO_OFFSET, 1217 VDESC_NO_OFFSET, 1218 VDESC_NO_OFFSET, 1219 VDESC_NO_OFFSET, 1220 NULL, 1221 }; 1222 #ifdef VNODE_OP_NOINLINE 1223 int 1224 VOP_ISLOCKED(vp) 1225 struct vnode *vp; 1226 { 1227 struct vop_islocked_args a; 1228 a.a_desc = VDESC(vop_islocked); 1229 a.a_vp = vp; 1230 return (VCALL(vp, VOFFSET(vop_islocked), &a)); 1231 } 1232 #endif 1233 1234 const int vop_pathconf_vp_offsets[] = { 1235 VOPARG_OFFSETOF(struct vop_pathconf_args,a_vp), 1236 VDESC_NO_OFFSET 1237 }; 1238 const struct vnodeop_desc vop_pathconf_desc = { 1239 37, 1240 "vop_pathconf", 1241 0, 1242 vop_pathconf_vp_offsets, 1243 VDESC_NO_OFFSET, 1244 VDESC_NO_OFFSET, 1245 VDESC_NO_OFFSET, 1246 VDESC_NO_OFFSET, 1247 NULL, 1248 }; 1249 #ifdef VNODE_OP_NOINLINE 1250 int 1251 VOP_PATHCONF(vp, name, retval) 1252 struct vnode *vp; 1253 int name; 1254 register_t *retval; 1255 { 1256 struct vop_pathconf_args a; 1257 a.a_desc = VDESC(vop_pathconf); 1258 a.a_vp = vp; 1259 a.a_name = name; 1260 a.a_retval = retval; 1261 return (VCALL(vp, VOFFSET(vop_pathconf), &a)); 1262 } 1263 #endif 1264 1265 const int vop_advlock_vp_offsets[] = { 1266 VOPARG_OFFSETOF(struct vop_advlock_args,a_vp), 1267 VDESC_NO_OFFSET 1268 }; 1269 const struct vnodeop_desc vop_advlock_desc = { 1270 38, 1271 "vop_advlock", 1272 0, 1273 vop_advlock_vp_offsets, 1274 VDESC_NO_OFFSET, 1275 VDESC_NO_OFFSET, 1276 VDESC_NO_OFFSET, 1277 VDESC_NO_OFFSET, 1278 NULL, 1279 }; 1280 #ifdef VNODE_OP_NOINLINE 1281 int 1282 VOP_ADVLOCK(vp, id, op, fl, flags) 1283 struct vnode *vp; 1284 caddr_t id; 1285 int op; 1286 struct flock *fl; 1287 int flags; 1288 { 1289 struct vop_advlock_args a; 1290 a.a_desc = VDESC(vop_advlock); 1291 a.a_vp = vp; 1292 a.a_id = id; 1293 a.a_op = op; 1294 a.a_fl = fl; 1295 a.a_flags = flags; 1296 return (VCALL(vp, VOFFSET(vop_advlock), &a)); 1297 } 1298 #endif 1299 1300 const int vop_blkatoff_vp_offsets[] = { 1301 VOPARG_OFFSETOF(struct vop_blkatoff_args,a_vp), 1302 VDESC_NO_OFFSET 1303 }; 1304 const struct vnodeop_desc vop_blkatoff_desc = { 1305 39, 1306 "vop_blkatoff", 1307 0, 1308 vop_blkatoff_vp_offsets, 1309 VDESC_NO_OFFSET, 1310 VDESC_NO_OFFSET, 1311 VDESC_NO_OFFSET, 1312 VDESC_NO_OFFSET, 1313 NULL, 1314 }; 1315 #ifdef VNODE_OP_NOINLINE 1316 int 1317 VOP_BLKATOFF(vp, offset, res, bpp) 1318 struct vnode *vp; 1319 off_t offset; 1320 char **res; 1321 struct buf **bpp; 1322 { 1323 struct vop_blkatoff_args a; 1324 a.a_desc = VDESC(vop_blkatoff); 1325 a.a_vp = vp; 1326 a.a_offset = offset; 1327 a.a_res = res; 1328 a.a_bpp = bpp; 1329 return (VCALL(vp, VOFFSET(vop_blkatoff), &a)); 1330 } 1331 #endif 1332 1333 const int vop_valloc_vp_offsets[] = { 1334 VOPARG_OFFSETOF(struct vop_valloc_args,a_pvp), 1335 VDESC_NO_OFFSET 1336 }; 1337 const struct vnodeop_desc vop_valloc_desc = { 1338 40, 1339 "vop_valloc", 1340 0, 1341 vop_valloc_vp_offsets, 1342 VOPARG_OFFSETOF(struct vop_valloc_args, a_vpp), 1343 VOPARG_OFFSETOF(struct vop_valloc_args, a_cred), 1344 VDESC_NO_OFFSET, 1345 VDESC_NO_OFFSET, 1346 NULL, 1347 }; 1348 #ifdef VNODE_OP_NOINLINE 1349 int 1350 VOP_VALLOC(pvp, mode, cred, vpp) 1351 struct vnode *pvp; 1352 int mode; 1353 struct ucred *cred; 1354 struct vnode **vpp; 1355 { 1356 struct vop_valloc_args a; 1357 a.a_desc = VDESC(vop_valloc); 1358 a.a_pvp = pvp; 1359 a.a_mode = mode; 1360 a.a_cred = cred; 1361 a.a_vpp = vpp; 1362 return (VCALL(pvp, VOFFSET(vop_valloc), &a)); 1363 } 1364 #endif 1365 1366 const int vop_balloc_vp_offsets[] = { 1367 VOPARG_OFFSETOF(struct vop_balloc_args,a_vp), 1368 VDESC_NO_OFFSET 1369 }; 1370 const struct vnodeop_desc vop_balloc_desc = { 1371 41, 1372 "vop_balloc", 1373 0, 1374 vop_balloc_vp_offsets, 1375 VDESC_NO_OFFSET, 1376 VOPARG_OFFSETOF(struct vop_balloc_args, a_cred), 1377 VDESC_NO_OFFSET, 1378 VDESC_NO_OFFSET, 1379 NULL, 1380 }; 1381 #ifdef VNODE_OP_NOINLINE 1382 int 1383 VOP_BALLOC(vp, startoffset, size, cred, flags, bpp) 1384 struct vnode *vp; 1385 off_t startoffset; 1386 int size; 1387 struct ucred *cred; 1388 int flags; 1389 struct buf **bpp; 1390 { 1391 struct vop_balloc_args a; 1392 a.a_desc = VDESC(vop_balloc); 1393 a.a_vp = vp; 1394 a.a_startoffset = startoffset; 1395 a.a_size = size; 1396 a.a_cred = cred; 1397 a.a_flags = flags; 1398 a.a_bpp = bpp; 1399 return (VCALL(vp, VOFFSET(vop_balloc), &a)); 1400 } 1401 #endif 1402 1403 const int vop_reallocblks_vp_offsets[] = { 1404 VOPARG_OFFSETOF(struct vop_reallocblks_args,a_vp), 1405 VDESC_NO_OFFSET 1406 }; 1407 const struct vnodeop_desc vop_reallocblks_desc = { 1408 42, 1409 "vop_reallocblks", 1410 0, 1411 vop_reallocblks_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_REALLOCBLKS(vp, buflist) 1421 struct vnode *vp; 1422 struct cluster_save *buflist; 1423 { 1424 struct vop_reallocblks_args a; 1425 a.a_desc = VDESC(vop_reallocblks); 1426 a.a_vp = vp; 1427 a.a_buflist = buflist; 1428 return (VCALL(vp, VOFFSET(vop_reallocblks), &a)); 1429 } 1430 #endif 1431 1432 const int vop_vfree_vp_offsets[] = { 1433 VOPARG_OFFSETOF(struct vop_vfree_args,a_pvp), 1434 VDESC_NO_OFFSET 1435 }; 1436 const struct vnodeop_desc vop_vfree_desc = { 1437 43, 1438 "vop_vfree", 1439 0, 1440 vop_vfree_vp_offsets, 1441 VDESC_NO_OFFSET, 1442 VDESC_NO_OFFSET, 1443 VDESC_NO_OFFSET, 1444 VDESC_NO_OFFSET, 1445 NULL, 1446 }; 1447 #ifdef VNODE_OP_NOINLINE 1448 int 1449 VOP_VFREE(pvp, ino, mode) 1450 struct vnode *pvp; 1451 ino_t ino; 1452 int mode; 1453 { 1454 struct vop_vfree_args a; 1455 a.a_desc = VDESC(vop_vfree); 1456 a.a_pvp = pvp; 1457 a.a_ino = ino; 1458 a.a_mode = mode; 1459 return (VCALL(pvp, VOFFSET(vop_vfree), &a)); 1460 } 1461 #endif 1462 1463 const int vop_truncate_vp_offsets[] = { 1464 VOPARG_OFFSETOF(struct vop_truncate_args,a_vp), 1465 VDESC_NO_OFFSET 1466 }; 1467 const struct vnodeop_desc vop_truncate_desc = { 1468 44, 1469 "vop_truncate", 1470 0, 1471 vop_truncate_vp_offsets, 1472 VDESC_NO_OFFSET, 1473 VOPARG_OFFSETOF(struct vop_truncate_args, a_cred), 1474 VOPARG_OFFSETOF(struct vop_truncate_args, a_p), 1475 VDESC_NO_OFFSET, 1476 NULL, 1477 }; 1478 #ifdef VNODE_OP_NOINLINE 1479 int 1480 VOP_TRUNCATE(vp, length, flags, cred, p) 1481 struct vnode *vp; 1482 off_t length; 1483 int flags; 1484 struct ucred *cred; 1485 struct proc *p; 1486 { 1487 struct vop_truncate_args a; 1488 a.a_desc = VDESC(vop_truncate); 1489 a.a_vp = vp; 1490 a.a_length = length; 1491 a.a_flags = flags; 1492 a.a_cred = cred; 1493 a.a_p = p; 1494 return (VCALL(vp, VOFFSET(vop_truncate), &a)); 1495 } 1496 #endif 1497 1498 const int vop_update_vp_offsets[] = { 1499 VOPARG_OFFSETOF(struct vop_update_args,a_vp), 1500 VDESC_NO_OFFSET 1501 }; 1502 const struct vnodeop_desc vop_update_desc = { 1503 45, 1504 "vop_update", 1505 0, 1506 vop_update_vp_offsets, 1507 VDESC_NO_OFFSET, 1508 VDESC_NO_OFFSET, 1509 VDESC_NO_OFFSET, 1510 VDESC_NO_OFFSET, 1511 NULL, 1512 }; 1513 #ifdef VNODE_OP_NOINLINE 1514 int 1515 VOP_UPDATE(vp, access, modify, flags) 1516 struct vnode *vp; 1517 struct timespec *access; 1518 struct timespec *modify; 1519 int flags; 1520 { 1521 struct vop_update_args a; 1522 a.a_desc = VDESC(vop_update); 1523 a.a_vp = vp; 1524 a.a_access = access; 1525 a.a_modify = modify; 1526 a.a_flags = flags; 1527 return (VCALL(vp, VOFFSET(vop_update), &a)); 1528 } 1529 #endif 1530 1531 const int vop_lease_vp_offsets[] = { 1532 VOPARG_OFFSETOF(struct vop_lease_args,a_vp), 1533 VDESC_NO_OFFSET 1534 }; 1535 const struct vnodeop_desc vop_lease_desc = { 1536 46, 1537 "vop_lease", 1538 0, 1539 vop_lease_vp_offsets, 1540 VDESC_NO_OFFSET, 1541 VOPARG_OFFSETOF(struct vop_lease_args, a_cred), 1542 VOPARG_OFFSETOF(struct vop_lease_args, a_p), 1543 VDESC_NO_OFFSET, 1544 NULL, 1545 }; 1546 #ifdef VNODE_OP_NOINLINE 1547 int 1548 VOP_LEASE(vp, p, cred, flag) 1549 struct vnode *vp; 1550 struct proc *p; 1551 struct ucred *cred; 1552 int flag; 1553 { 1554 struct vop_lease_args a; 1555 a.a_desc = VDESC(vop_lease); 1556 a.a_vp = vp; 1557 a.a_p = p; 1558 a.a_cred = cred; 1559 a.a_flag = flag; 1560 return (VCALL(vp, VOFFSET(vop_lease), &a)); 1561 } 1562 #endif 1563 1564 const int vop_whiteout_vp_offsets[] = { 1565 VOPARG_OFFSETOF(struct vop_whiteout_args,a_dvp), 1566 VDESC_NO_OFFSET 1567 }; 1568 const struct vnodeop_desc vop_whiteout_desc = { 1569 47, 1570 "vop_whiteout", 1571 0, 1572 vop_whiteout_vp_offsets, 1573 VDESC_NO_OFFSET, 1574 VDESC_NO_OFFSET, 1575 VDESC_NO_OFFSET, 1576 VOPARG_OFFSETOF(struct vop_whiteout_args, a_cnp), 1577 NULL, 1578 }; 1579 #ifdef VNODE_OP_NOINLINE 1580 int 1581 VOP_WHITEOUT(dvp, cnp, flags) 1582 struct vnode *dvp; 1583 struct componentname *cnp; 1584 int flags; 1585 { 1586 struct vop_whiteout_args a; 1587 a.a_desc = VDESC(vop_whiteout); 1588 a.a_dvp = dvp; 1589 a.a_cnp = cnp; 1590 a.a_flags = flags; 1591 return (VCALL(dvp, VOFFSET(vop_whiteout), &a)); 1592 } 1593 #endif 1594 1595 const int vop_getpages_vp_offsets[] = { 1596 VOPARG_OFFSETOF(struct vop_getpages_args,a_vp), 1597 VDESC_NO_OFFSET 1598 }; 1599 const struct vnodeop_desc vop_getpages_desc = { 1600 48, 1601 "vop_getpages", 1602 0, 1603 vop_getpages_vp_offsets, 1604 VDESC_NO_OFFSET, 1605 VDESC_NO_OFFSET, 1606 VDESC_NO_OFFSET, 1607 VDESC_NO_OFFSET, 1608 NULL, 1609 }; 1610 #ifdef VNODE_OP_NOINLINE 1611 int 1612 VOP_GETPAGES(vp, offset, m, count, centeridx, access_type, advice, flags) 1613 struct vnode *vp; 1614 voff_t offset; 1615 struct vm_page **m; 1616 int *count; 1617 int centeridx; 1618 vm_prot_t access_type; 1619 int advice; 1620 int flags; 1621 { 1622 struct vop_getpages_args a; 1623 a.a_desc = VDESC(vop_getpages); 1624 a.a_vp = vp; 1625 a.a_offset = offset; 1626 a.a_m = m; 1627 a.a_count = count; 1628 a.a_centeridx = centeridx; 1629 a.a_access_type = access_type; 1630 a.a_advice = advice; 1631 a.a_flags = flags; 1632 return (VCALL(vp, VOFFSET(vop_getpages), &a)); 1633 } 1634 #endif 1635 1636 const int vop_putpages_vp_offsets[] = { 1637 VOPARG_OFFSETOF(struct vop_putpages_args,a_vp), 1638 VDESC_NO_OFFSET 1639 }; 1640 const struct vnodeop_desc vop_putpages_desc = { 1641 49, 1642 "vop_putpages", 1643 0, 1644 vop_putpages_vp_offsets, 1645 VDESC_NO_OFFSET, 1646 VDESC_NO_OFFSET, 1647 VDESC_NO_OFFSET, 1648 VDESC_NO_OFFSET, 1649 NULL, 1650 }; 1651 #ifdef VNODE_OP_NOINLINE 1652 int 1653 VOP_PUTPAGES(vp, offlo, offhi, flags) 1654 struct vnode *vp; 1655 voff_t offlo; 1656 voff_t offhi; 1657 int flags; 1658 { 1659 struct vop_putpages_args a; 1660 a.a_desc = VDESC(vop_putpages); 1661 a.a_vp = vp; 1662 a.a_offlo = offlo; 1663 a.a_offhi = offhi; 1664 a.a_flags = flags; 1665 return (VCALL(vp, VOFFSET(vop_putpages), &a)); 1666 } 1667 #endif 1668 1669 /* End of special cases. */ 1670 1671 const struct vnodeop_desc * const vfs_op_descs[] = { 1672 &vop_default_desc, /* MUST BE FIRST */ 1673 &vop_strategy_desc, /* XXX: SPECIAL CASE */ 1674 &vop_bwrite_desc, /* XXX: SPECIAL CASE */ 1675 1676 &vop_lookup_desc, 1677 &vop_create_desc, 1678 &vop_mknod_desc, 1679 &vop_open_desc, 1680 &vop_close_desc, 1681 &vop_access_desc, 1682 &vop_getattr_desc, 1683 &vop_setattr_desc, 1684 &vop_read_desc, 1685 &vop_write_desc, 1686 &vop_ioctl_desc, 1687 &vop_fcntl_desc, 1688 &vop_poll_desc, 1689 &vop_kqfilter_desc, 1690 &vop_revoke_desc, 1691 &vop_mmap_desc, 1692 &vop_fsync_desc, 1693 &vop_seek_desc, 1694 &vop_remove_desc, 1695 &vop_link_desc, 1696 &vop_rename_desc, 1697 &vop_mkdir_desc, 1698 &vop_rmdir_desc, 1699 &vop_symlink_desc, 1700 &vop_readdir_desc, 1701 &vop_readlink_desc, 1702 &vop_abortop_desc, 1703 &vop_inactive_desc, 1704 &vop_reclaim_desc, 1705 &vop_lock_desc, 1706 &vop_unlock_desc, 1707 &vop_bmap_desc, 1708 &vop_print_desc, 1709 &vop_islocked_desc, 1710 &vop_pathconf_desc, 1711 &vop_advlock_desc, 1712 &vop_blkatoff_desc, 1713 &vop_valloc_desc, 1714 &vop_balloc_desc, 1715 &vop_reallocblks_desc, 1716 &vop_vfree_desc, 1717 &vop_truncate_desc, 1718 &vop_update_desc, 1719 &vop_lease_desc, 1720 &vop_whiteout_desc, 1721 &vop_getpages_desc, 1722 &vop_putpages_desc, 1723 NULL 1724 }; 1725 1726