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