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