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