vnode_if.c revision 1.52
1 /* $NetBSD: vnode_if.c,v 1.52 2005/02/26 22:10:31 perry Exp $ */ 2 3 /* 4 * Warning: DO NOT EDIT! This file is automatically generated! 5 * (Modifications made here may easily be lost!) 6 * 7 * Created from the file: 8 * NetBSD: vnode_if.src,v 1.43 2005/02/26 21:34:56 perry Exp 9 * by the script: 10 * NetBSD: vnode_if.sh,v 1.37 2005/02/26 21:40:45 perry Exp 11 */ 12 13 /* 14 * Copyright (c) 1992, 1993, 1994, 1995 15 * The Regents of the University of California. All rights reserved. 16 * 17 * Redistribution and use in source and binary forms, with or without 18 * modification, are permitted provided that the following conditions 19 * are met: 20 * 1. Redistributions of source code must retain the above copyright 21 * notice, this list of conditions and the following disclaimer. 22 * 2. Redistributions in binary form must reproduce the above copyright 23 * notice, this list of conditions and the following disclaimer in the 24 * documentation and/or other materials provided with the distribution. 25 * 3. Neither the name of the University nor the names of its contributors 26 * may be used to endorse or promote products derived from this software 27 * without specific prior written permission. 28 * 29 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 30 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 31 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 32 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 33 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 34 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 35 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 36 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 37 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 38 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 39 * SUCH DAMAGE. 40 */ 41 42 #include <sys/cdefs.h> 43 __KERNEL_RCSID(0, "$NetBSD: vnode_if.c,v 1.52 2005/02/26 22:10:31 perry Exp $"); 44 45 46 /* 47 * If we have LKM support, always include the non-inline versions for 48 * LKMs. Otherwise, do it based on the option. 49 */ 50 #ifdef LKM 51 #define VNODE_OP_NOINLINE 52 #else 53 #include "opt_vnode_op_noinline.h" 54 #endif 55 #include "opt_vnode_lockdebug.h" 56 57 #include <sys/param.h> 58 #include <sys/mount.h> 59 #include <sys/buf.h> 60 #include <sys/vnode.h> 61 62 const struct vnodeop_desc vop_default_desc = { 63 0, 64 "default", 65 0, 66 NULL, 67 VDESC_NO_OFFSET, 68 VDESC_NO_OFFSET, 69 VDESC_NO_OFFSET, 70 VDESC_NO_OFFSET, 71 NULL, 72 }; 73 74 75 /* Special cases: */ 76 77 const int vop_bwrite_vp_offsets[] = { 78 VDESC_NO_OFFSET 79 }; 80 const struct vnodeop_desc vop_bwrite_desc = { 81 1, 82 "vop_bwrite", 83 0, 84 vop_bwrite_vp_offsets, 85 VDESC_NO_OFFSET, 86 VDESC_NO_OFFSET, 87 VDESC_NO_OFFSET, 88 VDESC_NO_OFFSET, 89 NULL, 90 }; 91 #ifdef VNODE_OP_NOINLINE 92 int 93 VOP_BWRITE(bp) 94 struct buf *bp; 95 { 96 struct vop_bwrite_args a; 97 #ifdef VNODE_LOCKDEBUG 98 #endif 99 a.a_desc = VDESC(vop_bwrite); 100 a.a_bp = bp; 101 return (VCALL(bp->b_vp, VOFFSET(vop_bwrite), &a)); 102 } 103 #endif 104 105 /* End of special cases */ 106 107 const int vop_lookup_vp_offsets[] = { 108 VOPARG_OFFSETOF(struct vop_lookup_args,a_dvp), 109 VDESC_NO_OFFSET 110 }; 111 const struct vnodeop_desc vop_lookup_desc = { 112 2, 113 "vop_lookup", 114 0, 115 vop_lookup_vp_offsets, 116 VOPARG_OFFSETOF(struct vop_lookup_args, a_vpp), 117 VDESC_NO_OFFSET, 118 VDESC_NO_OFFSET, 119 VOPARG_OFFSETOF(struct vop_lookup_args, a_cnp), 120 NULL, 121 }; 122 #ifdef VNODE_OP_NOINLINE 123 int 124 VOP_LOOKUP(dvp, vpp, cnp) 125 struct vnode *dvp; 126 struct vnode **vpp; 127 struct componentname *cnp; 128 { 129 struct vop_lookup_args a; 130 #ifdef VNODE_LOCKDEBUG 131 #endif 132 a.a_desc = VDESC(vop_lookup); 133 a.a_dvp = dvp; 134 a.a_vpp = vpp; 135 a.a_cnp = cnp; 136 return (VCALL(dvp, VOFFSET(vop_lookup), &a)); 137 } 138 #endif 139 140 const int vop_create_vp_offsets[] = { 141 VOPARG_OFFSETOF(struct vop_create_args,a_dvp), 142 VDESC_NO_OFFSET 143 }; 144 const struct vnodeop_desc vop_create_desc = { 145 3, 146 "vop_create", 147 0 | VDESC_VP0_WILLPUT, 148 vop_create_vp_offsets, 149 VOPARG_OFFSETOF(struct vop_create_args, a_vpp), 150 VDESC_NO_OFFSET, 151 VDESC_NO_OFFSET, 152 VOPARG_OFFSETOF(struct vop_create_args, a_cnp), 153 NULL, 154 }; 155 #ifdef VNODE_OP_NOINLINE 156 int 157 VOP_CREATE(dvp, vpp, cnp, vap) 158 struct vnode *dvp; 159 struct vnode **vpp; 160 struct componentname *cnp; 161 struct vattr *vap; 162 { 163 struct vop_create_args a; 164 #ifdef VNODE_LOCKDEBUG 165 int islocked_dvp; 166 #endif 167 a.a_desc = VDESC(vop_create); 168 a.a_dvp = dvp; 169 #ifdef VNODE_LOCKDEBUG 170 islocked_dvp = (dvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1; 171 if (islocked_dvp != 1) 172 panic("vop_create: dvp: locked %d, expected %d", islocked_dvp, 1); 173 #endif 174 a.a_vpp = vpp; 175 a.a_cnp = cnp; 176 a.a_vap = vap; 177 return (VCALL(dvp, VOFFSET(vop_create), &a)); 178 } 179 #endif 180 181 const int vop_mknod_vp_offsets[] = { 182 VOPARG_OFFSETOF(struct vop_mknod_args,a_dvp), 183 VDESC_NO_OFFSET 184 }; 185 const struct vnodeop_desc vop_mknod_desc = { 186 4, 187 "vop_mknod", 188 0 | VDESC_VP0_WILLPUT, 189 vop_mknod_vp_offsets, 190 VOPARG_OFFSETOF(struct vop_mknod_args, a_vpp), 191 VDESC_NO_OFFSET, 192 VDESC_NO_OFFSET, 193 VOPARG_OFFSETOF(struct vop_mknod_args, a_cnp), 194 NULL, 195 }; 196 #ifdef VNODE_OP_NOINLINE 197 int 198 VOP_MKNOD(dvp, vpp, cnp, vap) 199 struct vnode *dvp; 200 struct vnode **vpp; 201 struct componentname *cnp; 202 struct vattr *vap; 203 { 204 struct vop_mknod_args a; 205 #ifdef VNODE_LOCKDEBUG 206 int islocked_dvp; 207 #endif 208 a.a_desc = VDESC(vop_mknod); 209 a.a_dvp = dvp; 210 #ifdef VNODE_LOCKDEBUG 211 islocked_dvp = (dvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1; 212 if (islocked_dvp != 1) 213 panic("vop_mknod: dvp: locked %d, expected %d", islocked_dvp, 1); 214 #endif 215 a.a_vpp = vpp; 216 a.a_cnp = cnp; 217 a.a_vap = vap; 218 return (VCALL(dvp, VOFFSET(vop_mknod), &a)); 219 } 220 #endif 221 222 const int vop_open_vp_offsets[] = { 223 VOPARG_OFFSETOF(struct vop_open_args,a_vp), 224 VDESC_NO_OFFSET 225 }; 226 const struct vnodeop_desc vop_open_desc = { 227 5, 228 "vop_open", 229 0, 230 vop_open_vp_offsets, 231 VDESC_NO_OFFSET, 232 VOPARG_OFFSETOF(struct vop_open_args, a_cred), 233 VOPARG_OFFSETOF(struct vop_open_args, a_p), 234 VDESC_NO_OFFSET, 235 NULL, 236 }; 237 #ifdef VNODE_OP_NOINLINE 238 int 239 VOP_OPEN(vp, mode, cred, p) 240 struct vnode *vp; 241 int mode; 242 struct ucred *cred; 243 struct proc *p; 244 { 245 struct vop_open_args a; 246 #ifdef VNODE_LOCKDEBUG 247 int islocked_vp; 248 #endif 249 a.a_desc = VDESC(vop_open); 250 a.a_vp = vp; 251 #ifdef VNODE_LOCKDEBUG 252 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 253 if (islocked_vp != 1) 254 panic("vop_open: vp: locked %d, expected %d", islocked_vp, 1); 255 #endif 256 a.a_mode = mode; 257 a.a_cred = cred; 258 a.a_p = p; 259 return (VCALL(vp, VOFFSET(vop_open), &a)); 260 } 261 #endif 262 263 const int vop_close_vp_offsets[] = { 264 VOPARG_OFFSETOF(struct vop_close_args,a_vp), 265 VDESC_NO_OFFSET 266 }; 267 const struct vnodeop_desc vop_close_desc = { 268 6, 269 "vop_close", 270 0, 271 vop_close_vp_offsets, 272 VDESC_NO_OFFSET, 273 VOPARG_OFFSETOF(struct vop_close_args, a_cred), 274 VOPARG_OFFSETOF(struct vop_close_args, a_p), 275 VDESC_NO_OFFSET, 276 NULL, 277 }; 278 #ifdef VNODE_OP_NOINLINE 279 int 280 VOP_CLOSE(vp, fflag, cred, p) 281 struct vnode *vp; 282 int fflag; 283 struct ucred *cred; 284 struct proc *p; 285 { 286 struct vop_close_args a; 287 #ifdef VNODE_LOCKDEBUG 288 int islocked_vp; 289 #endif 290 a.a_desc = VDESC(vop_close); 291 a.a_vp = vp; 292 #ifdef VNODE_LOCKDEBUG 293 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 294 if (islocked_vp != 1) 295 panic("vop_close: vp: locked %d, expected %d", islocked_vp, 1); 296 #endif 297 a.a_fflag = fflag; 298 a.a_cred = cred; 299 a.a_p = p; 300 return (VCALL(vp, VOFFSET(vop_close), &a)); 301 } 302 #endif 303 304 const int vop_access_vp_offsets[] = { 305 VOPARG_OFFSETOF(struct vop_access_args,a_vp), 306 VDESC_NO_OFFSET 307 }; 308 const struct vnodeop_desc vop_access_desc = { 309 7, 310 "vop_access", 311 0, 312 vop_access_vp_offsets, 313 VDESC_NO_OFFSET, 314 VOPARG_OFFSETOF(struct vop_access_args, a_cred), 315 VOPARG_OFFSETOF(struct vop_access_args, a_p), 316 VDESC_NO_OFFSET, 317 NULL, 318 }; 319 #ifdef VNODE_OP_NOINLINE 320 int 321 VOP_ACCESS(vp, mode, cred, p) 322 struct vnode *vp; 323 int mode; 324 struct ucred *cred; 325 struct proc *p; 326 { 327 struct vop_access_args a; 328 #ifdef VNODE_LOCKDEBUG 329 int islocked_vp; 330 #endif 331 a.a_desc = VDESC(vop_access); 332 a.a_vp = vp; 333 #ifdef VNODE_LOCKDEBUG 334 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 335 if (islocked_vp != 1) 336 panic("vop_access: vp: locked %d, expected %d", islocked_vp, 1); 337 #endif 338 a.a_mode = mode; 339 a.a_cred = cred; 340 a.a_p = p; 341 return (VCALL(vp, VOFFSET(vop_access), &a)); 342 } 343 #endif 344 345 const int vop_getattr_vp_offsets[] = { 346 VOPARG_OFFSETOF(struct vop_getattr_args,a_vp), 347 VDESC_NO_OFFSET 348 }; 349 const struct vnodeop_desc vop_getattr_desc = { 350 8, 351 "vop_getattr", 352 0, 353 vop_getattr_vp_offsets, 354 VDESC_NO_OFFSET, 355 VOPARG_OFFSETOF(struct vop_getattr_args, a_cred), 356 VOPARG_OFFSETOF(struct vop_getattr_args, a_p), 357 VDESC_NO_OFFSET, 358 NULL, 359 }; 360 #ifdef VNODE_OP_NOINLINE 361 int 362 VOP_GETATTR(vp, vap, cred, p) 363 struct vnode *vp; 364 struct vattr *vap; 365 struct ucred *cred; 366 struct proc *p; 367 { 368 struct vop_getattr_args a; 369 #ifdef VNODE_LOCKDEBUG 370 #endif 371 a.a_desc = VDESC(vop_getattr); 372 a.a_vp = vp; 373 a.a_vap = vap; 374 a.a_cred = cred; 375 a.a_p = p; 376 return (VCALL(vp, VOFFSET(vop_getattr), &a)); 377 } 378 #endif 379 380 const int vop_setattr_vp_offsets[] = { 381 VOPARG_OFFSETOF(struct vop_setattr_args,a_vp), 382 VDESC_NO_OFFSET 383 }; 384 const struct vnodeop_desc vop_setattr_desc = { 385 9, 386 "vop_setattr", 387 0, 388 vop_setattr_vp_offsets, 389 VDESC_NO_OFFSET, 390 VOPARG_OFFSETOF(struct vop_setattr_args, a_cred), 391 VOPARG_OFFSETOF(struct vop_setattr_args, a_p), 392 VDESC_NO_OFFSET, 393 NULL, 394 }; 395 #ifdef VNODE_OP_NOINLINE 396 int 397 VOP_SETATTR(vp, vap, cred, p) 398 struct vnode *vp; 399 struct vattr *vap; 400 struct ucred *cred; 401 struct proc *p; 402 { 403 struct vop_setattr_args a; 404 #ifdef VNODE_LOCKDEBUG 405 int islocked_vp; 406 #endif 407 a.a_desc = VDESC(vop_setattr); 408 a.a_vp = vp; 409 #ifdef VNODE_LOCKDEBUG 410 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 411 if (islocked_vp != 1) 412 panic("vop_setattr: vp: locked %d, expected %d", islocked_vp, 1); 413 #endif 414 a.a_vap = vap; 415 a.a_cred = cred; 416 a.a_p = p; 417 return (VCALL(vp, VOFFSET(vop_setattr), &a)); 418 } 419 #endif 420 421 const int vop_read_vp_offsets[] = { 422 VOPARG_OFFSETOF(struct vop_read_args,a_vp), 423 VDESC_NO_OFFSET 424 }; 425 const struct vnodeop_desc vop_read_desc = { 426 10, 427 "vop_read", 428 0, 429 vop_read_vp_offsets, 430 VDESC_NO_OFFSET, 431 VOPARG_OFFSETOF(struct vop_read_args, a_cred), 432 VDESC_NO_OFFSET, 433 VDESC_NO_OFFSET, 434 NULL, 435 }; 436 #ifdef VNODE_OP_NOINLINE 437 int 438 VOP_READ(vp, uio, ioflag, cred) 439 struct vnode *vp; 440 struct uio *uio; 441 int ioflag; 442 struct ucred *cred; 443 { 444 struct vop_read_args a; 445 #ifdef VNODE_LOCKDEBUG 446 int islocked_vp; 447 #endif 448 a.a_desc = VDESC(vop_read); 449 a.a_vp = vp; 450 #ifdef VNODE_LOCKDEBUG 451 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 452 if (islocked_vp != 1) 453 panic("vop_read: vp: locked %d, expected %d", islocked_vp, 1); 454 #endif 455 a.a_uio = uio; 456 a.a_ioflag = ioflag; 457 a.a_cred = cred; 458 return (VCALL(vp, VOFFSET(vop_read), &a)); 459 } 460 #endif 461 462 const int vop_write_vp_offsets[] = { 463 VOPARG_OFFSETOF(struct vop_write_args,a_vp), 464 VDESC_NO_OFFSET 465 }; 466 const struct vnodeop_desc vop_write_desc = { 467 11, 468 "vop_write", 469 0, 470 vop_write_vp_offsets, 471 VDESC_NO_OFFSET, 472 VOPARG_OFFSETOF(struct vop_write_args, a_cred), 473 VDESC_NO_OFFSET, 474 VDESC_NO_OFFSET, 475 NULL, 476 }; 477 #ifdef VNODE_OP_NOINLINE 478 int 479 VOP_WRITE(vp, uio, ioflag, cred) 480 struct vnode *vp; 481 struct uio *uio; 482 int ioflag; 483 struct ucred *cred; 484 { 485 struct vop_write_args a; 486 #ifdef VNODE_LOCKDEBUG 487 int islocked_vp; 488 #endif 489 a.a_desc = VDESC(vop_write); 490 a.a_vp = vp; 491 #ifdef VNODE_LOCKDEBUG 492 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 493 if (islocked_vp != 1) 494 panic("vop_write: vp: locked %d, expected %d", islocked_vp, 1); 495 #endif 496 a.a_uio = uio; 497 a.a_ioflag = ioflag; 498 a.a_cred = cred; 499 return (VCALL(vp, VOFFSET(vop_write), &a)); 500 } 501 #endif 502 503 const int vop_ioctl_vp_offsets[] = { 504 VOPARG_OFFSETOF(struct vop_ioctl_args,a_vp), 505 VDESC_NO_OFFSET 506 }; 507 const struct vnodeop_desc vop_ioctl_desc = { 508 12, 509 "vop_ioctl", 510 0, 511 vop_ioctl_vp_offsets, 512 VDESC_NO_OFFSET, 513 VOPARG_OFFSETOF(struct vop_ioctl_args, a_cred), 514 VOPARG_OFFSETOF(struct vop_ioctl_args, a_p), 515 VDESC_NO_OFFSET, 516 NULL, 517 }; 518 #ifdef VNODE_OP_NOINLINE 519 int 520 VOP_IOCTL(vp, command, data, fflag, cred, p) 521 struct vnode *vp; 522 u_long command; 523 void *data; 524 int fflag; 525 struct ucred *cred; 526 struct proc *p; 527 { 528 struct vop_ioctl_args a; 529 #ifdef VNODE_LOCKDEBUG 530 int islocked_vp; 531 #endif 532 a.a_desc = VDESC(vop_ioctl); 533 a.a_vp = vp; 534 #ifdef VNODE_LOCKDEBUG 535 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0; 536 if (islocked_vp != 0) 537 panic("vop_ioctl: vp: locked %d, expected %d", islocked_vp, 0); 538 #endif 539 a.a_command = command; 540 a.a_data = data; 541 a.a_fflag = fflag; 542 a.a_cred = cred; 543 a.a_p = p; 544 return (VCALL(vp, VOFFSET(vop_ioctl), &a)); 545 } 546 #endif 547 548 const int vop_fcntl_vp_offsets[] = { 549 VOPARG_OFFSETOF(struct vop_fcntl_args,a_vp), 550 VDESC_NO_OFFSET 551 }; 552 const struct vnodeop_desc vop_fcntl_desc = { 553 13, 554 "vop_fcntl", 555 0, 556 vop_fcntl_vp_offsets, 557 VDESC_NO_OFFSET, 558 VOPARG_OFFSETOF(struct vop_fcntl_args, a_cred), 559 VOPARG_OFFSETOF(struct vop_fcntl_args, a_p), 560 VDESC_NO_OFFSET, 561 NULL, 562 }; 563 #ifdef VNODE_OP_NOINLINE 564 int 565 VOP_FCNTL(vp, command, data, fflag, cred, p) 566 struct vnode *vp; 567 u_int command; 568 void *data; 569 int fflag; 570 struct ucred *cred; 571 struct proc *p; 572 { 573 struct vop_fcntl_args a; 574 #ifdef VNODE_LOCKDEBUG 575 int islocked_vp; 576 #endif 577 a.a_desc = VDESC(vop_fcntl); 578 a.a_vp = vp; 579 #ifdef VNODE_LOCKDEBUG 580 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 581 if (islocked_vp != 1) 582 panic("vop_fcntl: vp: locked %d, expected %d", islocked_vp, 1); 583 #endif 584 a.a_command = command; 585 a.a_data = data; 586 a.a_fflag = fflag; 587 a.a_cred = cred; 588 a.a_p = p; 589 return (VCALL(vp, VOFFSET(vop_fcntl), &a)); 590 } 591 #endif 592 593 const int vop_poll_vp_offsets[] = { 594 VOPARG_OFFSETOF(struct vop_poll_args,a_vp), 595 VDESC_NO_OFFSET 596 }; 597 const struct vnodeop_desc vop_poll_desc = { 598 14, 599 "vop_poll", 600 0, 601 vop_poll_vp_offsets, 602 VDESC_NO_OFFSET, 603 VDESC_NO_OFFSET, 604 VOPARG_OFFSETOF(struct vop_poll_args, a_p), 605 VDESC_NO_OFFSET, 606 NULL, 607 }; 608 #ifdef VNODE_OP_NOINLINE 609 int 610 VOP_POLL(vp, events, p) 611 struct vnode *vp; 612 int events; 613 struct proc *p; 614 { 615 struct vop_poll_args a; 616 #ifdef VNODE_LOCKDEBUG 617 int islocked_vp; 618 #endif 619 a.a_desc = VDESC(vop_poll); 620 a.a_vp = vp; 621 #ifdef VNODE_LOCKDEBUG 622 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0; 623 if (islocked_vp != 0) 624 panic("vop_poll: vp: locked %d, expected %d", islocked_vp, 0); 625 #endif 626 a.a_events = events; 627 a.a_p = p; 628 return (VCALL(vp, VOFFSET(vop_poll), &a)); 629 } 630 #endif 631 632 const int vop_kqfilter_vp_offsets[] = { 633 VOPARG_OFFSETOF(struct vop_kqfilter_args,a_vp), 634 VDESC_NO_OFFSET 635 }; 636 const struct vnodeop_desc vop_kqfilter_desc = { 637 15, 638 "vop_kqfilter", 639 0, 640 vop_kqfilter_vp_offsets, 641 VDESC_NO_OFFSET, 642 VDESC_NO_OFFSET, 643 VDESC_NO_OFFSET, 644 VDESC_NO_OFFSET, 645 NULL, 646 }; 647 #ifdef VNODE_OP_NOINLINE 648 int 649 VOP_KQFILTER(vp, kn) 650 struct vnode *vp; 651 struct knote *kn; 652 { 653 struct vop_kqfilter_args a; 654 #ifdef VNODE_LOCKDEBUG 655 int islocked_vp; 656 #endif 657 a.a_desc = VDESC(vop_kqfilter); 658 a.a_vp = vp; 659 #ifdef VNODE_LOCKDEBUG 660 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0; 661 if (islocked_vp != 0) 662 panic("vop_kqfilter: vp: locked %d, expected %d", islocked_vp, 0); 663 #endif 664 a.a_kn = kn; 665 return (VCALL(vp, VOFFSET(vop_kqfilter), &a)); 666 } 667 #endif 668 669 const int vop_revoke_vp_offsets[] = { 670 VOPARG_OFFSETOF(struct vop_revoke_args,a_vp), 671 VDESC_NO_OFFSET 672 }; 673 const struct vnodeop_desc vop_revoke_desc = { 674 16, 675 "vop_revoke", 676 0, 677 vop_revoke_vp_offsets, 678 VDESC_NO_OFFSET, 679 VDESC_NO_OFFSET, 680 VDESC_NO_OFFSET, 681 VDESC_NO_OFFSET, 682 NULL, 683 }; 684 #ifdef VNODE_OP_NOINLINE 685 int 686 VOP_REVOKE(vp, flags) 687 struct vnode *vp; 688 int flags; 689 { 690 struct vop_revoke_args a; 691 #ifdef VNODE_LOCKDEBUG 692 int islocked_vp; 693 #endif 694 a.a_desc = VDESC(vop_revoke); 695 a.a_vp = vp; 696 #ifdef VNODE_LOCKDEBUG 697 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0; 698 if (islocked_vp != 0) 699 panic("vop_revoke: vp: locked %d, expected %d", islocked_vp, 0); 700 #endif 701 a.a_flags = flags; 702 return (VCALL(vp, VOFFSET(vop_revoke), &a)); 703 } 704 #endif 705 706 const int vop_mmap_vp_offsets[] = { 707 VOPARG_OFFSETOF(struct vop_mmap_args,a_vp), 708 VDESC_NO_OFFSET 709 }; 710 const struct vnodeop_desc vop_mmap_desc = { 711 17, 712 "vop_mmap", 713 0, 714 vop_mmap_vp_offsets, 715 VDESC_NO_OFFSET, 716 VOPARG_OFFSETOF(struct vop_mmap_args, a_cred), 717 VOPARG_OFFSETOF(struct vop_mmap_args, a_p), 718 VDESC_NO_OFFSET, 719 NULL, 720 }; 721 #ifdef VNODE_OP_NOINLINE 722 int 723 VOP_MMAP(vp, fflags, cred, p) 724 struct vnode *vp; 725 int fflags; 726 struct ucred *cred; 727 struct proc *p; 728 { 729 struct vop_mmap_args a; 730 #ifdef VNODE_LOCKDEBUG 731 #endif 732 a.a_desc = VDESC(vop_mmap); 733 a.a_vp = vp; 734 a.a_fflags = fflags; 735 a.a_cred = cred; 736 a.a_p = p; 737 return (VCALL(vp, VOFFSET(vop_mmap), &a)); 738 } 739 #endif 740 741 const int vop_fsync_vp_offsets[] = { 742 VOPARG_OFFSETOF(struct vop_fsync_args,a_vp), 743 VDESC_NO_OFFSET 744 }; 745 const struct vnodeop_desc vop_fsync_desc = { 746 18, 747 "vop_fsync", 748 0, 749 vop_fsync_vp_offsets, 750 VDESC_NO_OFFSET, 751 VOPARG_OFFSETOF(struct vop_fsync_args, a_cred), 752 VOPARG_OFFSETOF(struct vop_fsync_args, a_p), 753 VDESC_NO_OFFSET, 754 NULL, 755 }; 756 #ifdef VNODE_OP_NOINLINE 757 int 758 VOP_FSYNC(vp, cred, flags, offlo, offhi, p) 759 struct vnode *vp; 760 struct ucred *cred; 761 int flags; 762 off_t offlo; 763 off_t offhi; 764 struct proc *p; 765 { 766 struct vop_fsync_args a; 767 #ifdef VNODE_LOCKDEBUG 768 int islocked_vp; 769 #endif 770 a.a_desc = VDESC(vop_fsync); 771 a.a_vp = vp; 772 #ifdef VNODE_LOCKDEBUG 773 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 774 if (islocked_vp != 1) 775 panic("vop_fsync: vp: locked %d, expected %d", islocked_vp, 1); 776 #endif 777 a.a_cred = cred; 778 a.a_flags = flags; 779 a.a_offlo = offlo; 780 a.a_offhi = offhi; 781 a.a_p = p; 782 return (VCALL(vp, VOFFSET(vop_fsync), &a)); 783 } 784 #endif 785 786 const int vop_seek_vp_offsets[] = { 787 VOPARG_OFFSETOF(struct vop_seek_args,a_vp), 788 VDESC_NO_OFFSET 789 }; 790 const struct vnodeop_desc vop_seek_desc = { 791 19, 792 "vop_seek", 793 0, 794 vop_seek_vp_offsets, 795 VDESC_NO_OFFSET, 796 VOPARG_OFFSETOF(struct vop_seek_args, a_cred), 797 VDESC_NO_OFFSET, 798 VDESC_NO_OFFSET, 799 NULL, 800 }; 801 #ifdef VNODE_OP_NOINLINE 802 int 803 VOP_SEEK(vp, oldoff, newoff, cred) 804 struct vnode *vp; 805 off_t oldoff; 806 off_t newoff; 807 struct ucred *cred; 808 { 809 struct vop_seek_args a; 810 #ifdef VNODE_LOCKDEBUG 811 #endif 812 a.a_desc = VDESC(vop_seek); 813 a.a_vp = vp; 814 a.a_oldoff = oldoff; 815 a.a_newoff = newoff; 816 a.a_cred = cred; 817 return (VCALL(vp, VOFFSET(vop_seek), &a)); 818 } 819 #endif 820 821 const int vop_remove_vp_offsets[] = { 822 VOPARG_OFFSETOF(struct vop_remove_args,a_dvp), 823 VOPARG_OFFSETOF(struct vop_remove_args,a_vp), 824 VDESC_NO_OFFSET 825 }; 826 const struct vnodeop_desc vop_remove_desc = { 827 20, 828 "vop_remove", 829 0 | VDESC_VP0_WILLPUT | VDESC_VP1_WILLPUT, 830 vop_remove_vp_offsets, 831 VDESC_NO_OFFSET, 832 VDESC_NO_OFFSET, 833 VDESC_NO_OFFSET, 834 VOPARG_OFFSETOF(struct vop_remove_args, a_cnp), 835 NULL, 836 }; 837 #ifdef VNODE_OP_NOINLINE 838 int 839 VOP_REMOVE(dvp, vp, cnp) 840 struct vnode *dvp; 841 struct vnode *vp; 842 struct componentname *cnp; 843 { 844 struct vop_remove_args a; 845 #ifdef VNODE_LOCKDEBUG 846 int islocked_dvp; 847 int islocked_vp; 848 #endif 849 a.a_desc = VDESC(vop_remove); 850 a.a_dvp = dvp; 851 #ifdef VNODE_LOCKDEBUG 852 islocked_dvp = (dvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1; 853 if (islocked_dvp != 1) 854 panic("vop_remove: dvp: locked %d, expected %d", islocked_dvp, 1); 855 #endif 856 a.a_vp = vp; 857 #ifdef VNODE_LOCKDEBUG 858 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 859 if (islocked_vp != 1) 860 panic("vop_remove: vp: locked %d, expected %d", islocked_vp, 1); 861 #endif 862 a.a_cnp = cnp; 863 return (VCALL(dvp, VOFFSET(vop_remove), &a)); 864 } 865 #endif 866 867 const int vop_link_vp_offsets[] = { 868 VOPARG_OFFSETOF(struct vop_link_args,a_dvp), 869 VOPARG_OFFSETOF(struct vop_link_args,a_vp), 870 VDESC_NO_OFFSET 871 }; 872 const struct vnodeop_desc vop_link_desc = { 873 21, 874 "vop_link", 875 0 | VDESC_VP0_WILLPUT, 876 vop_link_vp_offsets, 877 VDESC_NO_OFFSET, 878 VDESC_NO_OFFSET, 879 VDESC_NO_OFFSET, 880 VOPARG_OFFSETOF(struct vop_link_args, a_cnp), 881 NULL, 882 }; 883 #ifdef VNODE_OP_NOINLINE 884 int 885 VOP_LINK(dvp, vp, cnp) 886 struct vnode *dvp; 887 struct vnode *vp; 888 struct componentname *cnp; 889 { 890 struct vop_link_args a; 891 #ifdef VNODE_LOCKDEBUG 892 int islocked_dvp; 893 int islocked_vp; 894 #endif 895 a.a_desc = VDESC(vop_link); 896 a.a_dvp = dvp; 897 #ifdef VNODE_LOCKDEBUG 898 islocked_dvp = (dvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1; 899 if (islocked_dvp != 1) 900 panic("vop_link: dvp: locked %d, expected %d", islocked_dvp, 1); 901 #endif 902 a.a_vp = vp; 903 #ifdef VNODE_LOCKDEBUG 904 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0; 905 if (islocked_vp != 0) 906 panic("vop_link: vp: locked %d, expected %d", islocked_vp, 0); 907 #endif 908 a.a_cnp = cnp; 909 return (VCALL(dvp, VOFFSET(vop_link), &a)); 910 } 911 #endif 912 913 const int vop_rename_vp_offsets[] = { 914 VOPARG_OFFSETOF(struct vop_rename_args,a_fdvp), 915 VOPARG_OFFSETOF(struct vop_rename_args,a_fvp), 916 VOPARG_OFFSETOF(struct vop_rename_args,a_tdvp), 917 VOPARG_OFFSETOF(struct vop_rename_args,a_tvp), 918 VDESC_NO_OFFSET 919 }; 920 const struct vnodeop_desc vop_rename_desc = { 921 22, 922 "vop_rename", 923 0 | VDESC_VP0_WILLRELE | VDESC_VP1_WILLRELE | VDESC_VP2_WILLPUT | VDESC_VP3_WILLPUT, 924 vop_rename_vp_offsets, 925 VDESC_NO_OFFSET, 926 VDESC_NO_OFFSET, 927 VDESC_NO_OFFSET, 928 VOPARG_OFFSETOF(struct vop_rename_args, a_fcnp), 929 NULL, 930 }; 931 #ifdef VNODE_OP_NOINLINE 932 int 933 VOP_RENAME(fdvp, fvp, fcnp, tdvp, tvp, tcnp) 934 struct vnode *fdvp; 935 struct vnode *fvp; 936 struct componentname *fcnp; 937 struct vnode *tdvp; 938 struct vnode *tvp; 939 struct componentname *tcnp; 940 { 941 struct vop_rename_args a; 942 #ifdef VNODE_LOCKDEBUG 943 int islocked_fdvp; 944 int islocked_fvp; 945 int islocked_tdvp; 946 #endif 947 a.a_desc = VDESC(vop_rename); 948 a.a_fdvp = fdvp; 949 #ifdef VNODE_LOCKDEBUG 950 islocked_fdvp = (fdvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(fdvp) == LK_EXCLUSIVE) : 0; 951 if (islocked_fdvp != 0) 952 panic("vop_rename: fdvp: locked %d, expected %d", islocked_fdvp, 0); 953 #endif 954 a.a_fvp = fvp; 955 #ifdef VNODE_LOCKDEBUG 956 islocked_fvp = (fvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(fvp) == LK_EXCLUSIVE) : 0; 957 if (islocked_fvp != 0) 958 panic("vop_rename: fvp: locked %d, expected %d", islocked_fvp, 0); 959 #endif 960 a.a_fcnp = fcnp; 961 a.a_tdvp = tdvp; 962 #ifdef VNODE_LOCKDEBUG 963 islocked_tdvp = (tdvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(tdvp) == LK_EXCLUSIVE) : 1; 964 if (islocked_tdvp != 1) 965 panic("vop_rename: tdvp: locked %d, expected %d", islocked_tdvp, 1); 966 #endif 967 a.a_tvp = tvp; 968 a.a_tcnp = tcnp; 969 return (VCALL(fdvp, VOFFSET(vop_rename), &a)); 970 } 971 #endif 972 973 const int vop_mkdir_vp_offsets[] = { 974 VOPARG_OFFSETOF(struct vop_mkdir_args,a_dvp), 975 VDESC_NO_OFFSET 976 }; 977 const struct vnodeop_desc vop_mkdir_desc = { 978 23, 979 "vop_mkdir", 980 0 | VDESC_VP0_WILLPUT, 981 vop_mkdir_vp_offsets, 982 VOPARG_OFFSETOF(struct vop_mkdir_args, a_vpp), 983 VDESC_NO_OFFSET, 984 VDESC_NO_OFFSET, 985 VOPARG_OFFSETOF(struct vop_mkdir_args, a_cnp), 986 NULL, 987 }; 988 #ifdef VNODE_OP_NOINLINE 989 int 990 VOP_MKDIR(dvp, vpp, cnp, vap) 991 struct vnode *dvp; 992 struct vnode **vpp; 993 struct componentname *cnp; 994 struct vattr *vap; 995 { 996 struct vop_mkdir_args a; 997 #ifdef VNODE_LOCKDEBUG 998 int islocked_dvp; 999 #endif 1000 a.a_desc = VDESC(vop_mkdir); 1001 a.a_dvp = dvp; 1002 #ifdef VNODE_LOCKDEBUG 1003 islocked_dvp = (dvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1; 1004 if (islocked_dvp != 1) 1005 panic("vop_mkdir: dvp: locked %d, expected %d", islocked_dvp, 1); 1006 #endif 1007 a.a_vpp = vpp; 1008 a.a_cnp = cnp; 1009 a.a_vap = vap; 1010 return (VCALL(dvp, VOFFSET(vop_mkdir), &a)); 1011 } 1012 #endif 1013 1014 const int vop_rmdir_vp_offsets[] = { 1015 VOPARG_OFFSETOF(struct vop_rmdir_args,a_dvp), 1016 VOPARG_OFFSETOF(struct vop_rmdir_args,a_vp), 1017 VDESC_NO_OFFSET 1018 }; 1019 const struct vnodeop_desc vop_rmdir_desc = { 1020 24, 1021 "vop_rmdir", 1022 0 | VDESC_VP0_WILLPUT | VDESC_VP1_WILLPUT, 1023 vop_rmdir_vp_offsets, 1024 VDESC_NO_OFFSET, 1025 VDESC_NO_OFFSET, 1026 VDESC_NO_OFFSET, 1027 VOPARG_OFFSETOF(struct vop_rmdir_args, a_cnp), 1028 NULL, 1029 }; 1030 #ifdef VNODE_OP_NOINLINE 1031 int 1032 VOP_RMDIR(dvp, vp, cnp) 1033 struct vnode *dvp; 1034 struct vnode *vp; 1035 struct componentname *cnp; 1036 { 1037 struct vop_rmdir_args a; 1038 #ifdef VNODE_LOCKDEBUG 1039 int islocked_dvp; 1040 int islocked_vp; 1041 #endif 1042 a.a_desc = VDESC(vop_rmdir); 1043 a.a_dvp = dvp; 1044 #ifdef VNODE_LOCKDEBUG 1045 islocked_dvp = (dvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1; 1046 if (islocked_dvp != 1) 1047 panic("vop_rmdir: dvp: locked %d, expected %d", islocked_dvp, 1); 1048 #endif 1049 a.a_vp = vp; 1050 #ifdef VNODE_LOCKDEBUG 1051 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1052 if (islocked_vp != 1) 1053 panic("vop_rmdir: vp: locked %d, expected %d", islocked_vp, 1); 1054 #endif 1055 a.a_cnp = cnp; 1056 return (VCALL(dvp, VOFFSET(vop_rmdir), &a)); 1057 } 1058 #endif 1059 1060 const int vop_symlink_vp_offsets[] = { 1061 VOPARG_OFFSETOF(struct vop_symlink_args,a_dvp), 1062 VDESC_NO_OFFSET 1063 }; 1064 const struct vnodeop_desc vop_symlink_desc = { 1065 25, 1066 "vop_symlink", 1067 0 | VDESC_VP0_WILLPUT, 1068 vop_symlink_vp_offsets, 1069 VOPARG_OFFSETOF(struct vop_symlink_args, a_vpp), 1070 VDESC_NO_OFFSET, 1071 VDESC_NO_OFFSET, 1072 VOPARG_OFFSETOF(struct vop_symlink_args, a_cnp), 1073 NULL, 1074 }; 1075 #ifdef VNODE_OP_NOINLINE 1076 int 1077 VOP_SYMLINK(dvp, vpp, cnp, vap, target) 1078 struct vnode *dvp; 1079 struct vnode **vpp; 1080 struct componentname *cnp; 1081 struct vattr *vap; 1082 char *target; 1083 { 1084 struct vop_symlink_args a; 1085 #ifdef VNODE_LOCKDEBUG 1086 int islocked_dvp; 1087 #endif 1088 a.a_desc = VDESC(vop_symlink); 1089 a.a_dvp = dvp; 1090 #ifdef VNODE_LOCKDEBUG 1091 islocked_dvp = (dvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1; 1092 if (islocked_dvp != 1) 1093 panic("vop_symlink: dvp: locked %d, expected %d", islocked_dvp, 1); 1094 #endif 1095 a.a_vpp = vpp; 1096 a.a_cnp = cnp; 1097 a.a_vap = vap; 1098 a.a_target = target; 1099 return (VCALL(dvp, VOFFSET(vop_symlink), &a)); 1100 } 1101 #endif 1102 1103 const int vop_readdir_vp_offsets[] = { 1104 VOPARG_OFFSETOF(struct vop_readdir_args,a_vp), 1105 VDESC_NO_OFFSET 1106 }; 1107 const struct vnodeop_desc vop_readdir_desc = { 1108 26, 1109 "vop_readdir", 1110 0, 1111 vop_readdir_vp_offsets, 1112 VDESC_NO_OFFSET, 1113 VOPARG_OFFSETOF(struct vop_readdir_args, a_cred), 1114 VDESC_NO_OFFSET, 1115 VDESC_NO_OFFSET, 1116 NULL, 1117 }; 1118 #ifdef VNODE_OP_NOINLINE 1119 int 1120 VOP_READDIR(vp, uio, cred, eofflag, cookies, ncookies) 1121 struct vnode *vp; 1122 struct uio *uio; 1123 struct ucred *cred; 1124 int *eofflag; 1125 off_t **cookies; 1126 int *ncookies; 1127 { 1128 struct vop_readdir_args a; 1129 #ifdef VNODE_LOCKDEBUG 1130 int islocked_vp; 1131 #endif 1132 a.a_desc = VDESC(vop_readdir); 1133 a.a_vp = vp; 1134 #ifdef VNODE_LOCKDEBUG 1135 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1136 if (islocked_vp != 1) 1137 panic("vop_readdir: vp: locked %d, expected %d", islocked_vp, 1); 1138 #endif 1139 a.a_uio = uio; 1140 a.a_cred = cred; 1141 a.a_eofflag = eofflag; 1142 a.a_cookies = cookies; 1143 a.a_ncookies = ncookies; 1144 return (VCALL(vp, VOFFSET(vop_readdir), &a)); 1145 } 1146 #endif 1147 1148 const int vop_readlink_vp_offsets[] = { 1149 VOPARG_OFFSETOF(struct vop_readlink_args,a_vp), 1150 VDESC_NO_OFFSET 1151 }; 1152 const struct vnodeop_desc vop_readlink_desc = { 1153 27, 1154 "vop_readlink", 1155 0, 1156 vop_readlink_vp_offsets, 1157 VDESC_NO_OFFSET, 1158 VOPARG_OFFSETOF(struct vop_readlink_args, a_cred), 1159 VDESC_NO_OFFSET, 1160 VDESC_NO_OFFSET, 1161 NULL, 1162 }; 1163 #ifdef VNODE_OP_NOINLINE 1164 int 1165 VOP_READLINK(vp, uio, cred) 1166 struct vnode *vp; 1167 struct uio *uio; 1168 struct ucred *cred; 1169 { 1170 struct vop_readlink_args a; 1171 #ifdef VNODE_LOCKDEBUG 1172 int islocked_vp; 1173 #endif 1174 a.a_desc = VDESC(vop_readlink); 1175 a.a_vp = vp; 1176 #ifdef VNODE_LOCKDEBUG 1177 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1178 if (islocked_vp != 1) 1179 panic("vop_readlink: vp: locked %d, expected %d", islocked_vp, 1); 1180 #endif 1181 a.a_uio = uio; 1182 a.a_cred = cred; 1183 return (VCALL(vp, VOFFSET(vop_readlink), &a)); 1184 } 1185 #endif 1186 1187 const int vop_abortop_vp_offsets[] = { 1188 VOPARG_OFFSETOF(struct vop_abortop_args,a_dvp), 1189 VDESC_NO_OFFSET 1190 }; 1191 const struct vnodeop_desc vop_abortop_desc = { 1192 28, 1193 "vop_abortop", 1194 0, 1195 vop_abortop_vp_offsets, 1196 VDESC_NO_OFFSET, 1197 VDESC_NO_OFFSET, 1198 VDESC_NO_OFFSET, 1199 VOPARG_OFFSETOF(struct vop_abortop_args, a_cnp), 1200 NULL, 1201 }; 1202 #ifdef VNODE_OP_NOINLINE 1203 int 1204 VOP_ABORTOP(dvp, cnp) 1205 struct vnode *dvp; 1206 struct componentname *cnp; 1207 { 1208 struct vop_abortop_args a; 1209 #ifdef VNODE_LOCKDEBUG 1210 #endif 1211 a.a_desc = VDESC(vop_abortop); 1212 a.a_dvp = dvp; 1213 a.a_cnp = cnp; 1214 return (VCALL(dvp, VOFFSET(vop_abortop), &a)); 1215 } 1216 #endif 1217 1218 const int vop_inactive_vp_offsets[] = { 1219 VOPARG_OFFSETOF(struct vop_inactive_args,a_vp), 1220 VDESC_NO_OFFSET 1221 }; 1222 const struct vnodeop_desc vop_inactive_desc = { 1223 29, 1224 "vop_inactive", 1225 0 | VDESC_VP0_WILLUNLOCK, 1226 vop_inactive_vp_offsets, 1227 VDESC_NO_OFFSET, 1228 VDESC_NO_OFFSET, 1229 VOPARG_OFFSETOF(struct vop_inactive_args, a_p), 1230 VDESC_NO_OFFSET, 1231 NULL, 1232 }; 1233 #ifdef VNODE_OP_NOINLINE 1234 int 1235 VOP_INACTIVE(vp, p) 1236 struct vnode *vp; 1237 struct proc *p; 1238 { 1239 struct vop_inactive_args a; 1240 #ifdef VNODE_LOCKDEBUG 1241 int islocked_vp; 1242 #endif 1243 a.a_desc = VDESC(vop_inactive); 1244 a.a_vp = vp; 1245 #ifdef VNODE_LOCKDEBUG 1246 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1247 if (islocked_vp != 1) 1248 panic("vop_inactive: vp: locked %d, expected %d", islocked_vp, 1); 1249 #endif 1250 a.a_p = p; 1251 return (VCALL(vp, VOFFSET(vop_inactive), &a)); 1252 } 1253 #endif 1254 1255 const int vop_reclaim_vp_offsets[] = { 1256 VOPARG_OFFSETOF(struct vop_reclaim_args,a_vp), 1257 VDESC_NO_OFFSET 1258 }; 1259 const struct vnodeop_desc vop_reclaim_desc = { 1260 30, 1261 "vop_reclaim", 1262 0, 1263 vop_reclaim_vp_offsets, 1264 VDESC_NO_OFFSET, 1265 VDESC_NO_OFFSET, 1266 VOPARG_OFFSETOF(struct vop_reclaim_args, a_p), 1267 VDESC_NO_OFFSET, 1268 NULL, 1269 }; 1270 #ifdef VNODE_OP_NOINLINE 1271 int 1272 VOP_RECLAIM(vp, p) 1273 struct vnode *vp; 1274 struct proc *p; 1275 { 1276 struct vop_reclaim_args a; 1277 #ifdef VNODE_LOCKDEBUG 1278 int islocked_vp; 1279 #endif 1280 a.a_desc = VDESC(vop_reclaim); 1281 a.a_vp = vp; 1282 #ifdef VNODE_LOCKDEBUG 1283 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0; 1284 if (islocked_vp != 0) 1285 panic("vop_reclaim: vp: locked %d, expected %d", islocked_vp, 0); 1286 #endif 1287 a.a_p = p; 1288 return (VCALL(vp, VOFFSET(vop_reclaim), &a)); 1289 } 1290 #endif 1291 1292 const int vop_lock_vp_offsets[] = { 1293 VOPARG_OFFSETOF(struct vop_lock_args,a_vp), 1294 VDESC_NO_OFFSET 1295 }; 1296 const struct vnodeop_desc vop_lock_desc = { 1297 31, 1298 "vop_lock", 1299 0, 1300 vop_lock_vp_offsets, 1301 VDESC_NO_OFFSET, 1302 VDESC_NO_OFFSET, 1303 VDESC_NO_OFFSET, 1304 VDESC_NO_OFFSET, 1305 NULL, 1306 }; 1307 #ifdef VNODE_OP_NOINLINE 1308 int 1309 VOP_LOCK(vp, flags) 1310 struct vnode *vp; 1311 int flags; 1312 { 1313 struct vop_lock_args a; 1314 #ifdef VNODE_LOCKDEBUG 1315 int islocked_vp; 1316 #endif 1317 a.a_desc = VDESC(vop_lock); 1318 a.a_vp = vp; 1319 #ifdef VNODE_LOCKDEBUG 1320 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0; 1321 if (islocked_vp != 0) 1322 panic("vop_lock: vp: locked %d, expected %d", islocked_vp, 0); 1323 #endif 1324 a.a_flags = flags; 1325 return (VCALL(vp, VOFFSET(vop_lock), &a)); 1326 } 1327 #endif 1328 1329 const int vop_unlock_vp_offsets[] = { 1330 VOPARG_OFFSETOF(struct vop_unlock_args,a_vp), 1331 VDESC_NO_OFFSET 1332 }; 1333 const struct vnodeop_desc vop_unlock_desc = { 1334 32, 1335 "vop_unlock", 1336 0, 1337 vop_unlock_vp_offsets, 1338 VDESC_NO_OFFSET, 1339 VDESC_NO_OFFSET, 1340 VDESC_NO_OFFSET, 1341 VDESC_NO_OFFSET, 1342 NULL, 1343 }; 1344 #ifdef VNODE_OP_NOINLINE 1345 int 1346 VOP_UNLOCK(vp, flags) 1347 struct vnode *vp; 1348 int flags; 1349 { 1350 struct vop_unlock_args a; 1351 #ifdef VNODE_LOCKDEBUG 1352 int islocked_vp; 1353 #endif 1354 a.a_desc = VDESC(vop_unlock); 1355 a.a_vp = vp; 1356 #ifdef VNODE_LOCKDEBUG 1357 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1358 if (islocked_vp != 1) 1359 panic("vop_unlock: vp: locked %d, expected %d", islocked_vp, 1); 1360 #endif 1361 a.a_flags = flags; 1362 return (VCALL(vp, VOFFSET(vop_unlock), &a)); 1363 } 1364 #endif 1365 1366 const int vop_bmap_vp_offsets[] = { 1367 VOPARG_OFFSETOF(struct vop_bmap_args,a_vp), 1368 VDESC_NO_OFFSET 1369 }; 1370 const struct vnodeop_desc vop_bmap_desc = { 1371 33, 1372 "vop_bmap", 1373 0, 1374 vop_bmap_vp_offsets, 1375 VOPARG_OFFSETOF(struct vop_bmap_args, a_vpp), 1376 VDESC_NO_OFFSET, 1377 VDESC_NO_OFFSET, 1378 VDESC_NO_OFFSET, 1379 NULL, 1380 }; 1381 #ifdef VNODE_OP_NOINLINE 1382 int 1383 VOP_BMAP(vp, bn, vpp, bnp, runp) 1384 struct vnode *vp; 1385 daddr_t bn; 1386 struct vnode **vpp; 1387 daddr_t *bnp; 1388 int *runp; 1389 { 1390 struct vop_bmap_args a; 1391 #ifdef VNODE_LOCKDEBUG 1392 int islocked_vp; 1393 #endif 1394 a.a_desc = VDESC(vop_bmap); 1395 a.a_vp = vp; 1396 #ifdef VNODE_LOCKDEBUG 1397 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1398 if (islocked_vp != 1) 1399 panic("vop_bmap: vp: locked %d, expected %d", islocked_vp, 1); 1400 #endif 1401 a.a_bn = bn; 1402 a.a_vpp = vpp; 1403 a.a_bnp = bnp; 1404 a.a_runp = runp; 1405 return (VCALL(vp, VOFFSET(vop_bmap), &a)); 1406 } 1407 #endif 1408 1409 const int vop_strategy_vp_offsets[] = { 1410 VOPARG_OFFSETOF(struct vop_strategy_args,a_vp), 1411 VDESC_NO_OFFSET 1412 }; 1413 const struct vnodeop_desc vop_strategy_desc = { 1414 34, 1415 "vop_strategy", 1416 0, 1417 vop_strategy_vp_offsets, 1418 VDESC_NO_OFFSET, 1419 VDESC_NO_OFFSET, 1420 VDESC_NO_OFFSET, 1421 VDESC_NO_OFFSET, 1422 NULL, 1423 }; 1424 #ifdef VNODE_OP_NOINLINE 1425 int 1426 VOP_STRATEGY(vp, bp) 1427 struct vnode *vp; 1428 struct buf *bp; 1429 { 1430 struct vop_strategy_args a; 1431 #ifdef VNODE_LOCKDEBUG 1432 #endif 1433 a.a_desc = VDESC(vop_strategy); 1434 a.a_vp = vp; 1435 a.a_bp = bp; 1436 return (VCALL(vp, VOFFSET(vop_strategy), &a)); 1437 } 1438 #endif 1439 1440 const int vop_print_vp_offsets[] = { 1441 VOPARG_OFFSETOF(struct vop_print_args,a_vp), 1442 VDESC_NO_OFFSET 1443 }; 1444 const struct vnodeop_desc vop_print_desc = { 1445 35, 1446 "vop_print", 1447 0, 1448 vop_print_vp_offsets, 1449 VDESC_NO_OFFSET, 1450 VDESC_NO_OFFSET, 1451 VDESC_NO_OFFSET, 1452 VDESC_NO_OFFSET, 1453 NULL, 1454 }; 1455 #ifdef VNODE_OP_NOINLINE 1456 int 1457 VOP_PRINT(vp) 1458 struct vnode *vp; 1459 { 1460 struct vop_print_args a; 1461 #ifdef VNODE_LOCKDEBUG 1462 #endif 1463 a.a_desc = VDESC(vop_print); 1464 a.a_vp = vp; 1465 return (VCALL(vp, VOFFSET(vop_print), &a)); 1466 } 1467 #endif 1468 1469 const int vop_islocked_vp_offsets[] = { 1470 VOPARG_OFFSETOF(struct vop_islocked_args,a_vp), 1471 VDESC_NO_OFFSET 1472 }; 1473 const struct vnodeop_desc vop_islocked_desc = { 1474 36, 1475 "vop_islocked", 1476 0, 1477 vop_islocked_vp_offsets, 1478 VDESC_NO_OFFSET, 1479 VDESC_NO_OFFSET, 1480 VDESC_NO_OFFSET, 1481 VDESC_NO_OFFSET, 1482 NULL, 1483 }; 1484 #ifdef VNODE_OP_NOINLINE 1485 int 1486 VOP_ISLOCKED(vp) 1487 struct vnode *vp; 1488 { 1489 struct vop_islocked_args a; 1490 #ifdef VNODE_LOCKDEBUG 1491 #endif 1492 a.a_desc = VDESC(vop_islocked); 1493 a.a_vp = vp; 1494 return (VCALL(vp, VOFFSET(vop_islocked), &a)); 1495 } 1496 #endif 1497 1498 const int vop_pathconf_vp_offsets[] = { 1499 VOPARG_OFFSETOF(struct vop_pathconf_args,a_vp), 1500 VDESC_NO_OFFSET 1501 }; 1502 const struct vnodeop_desc vop_pathconf_desc = { 1503 37, 1504 "vop_pathconf", 1505 0, 1506 vop_pathconf_vp_offsets, 1507 VDESC_NO_OFFSET, 1508 VDESC_NO_OFFSET, 1509 VDESC_NO_OFFSET, 1510 VDESC_NO_OFFSET, 1511 NULL, 1512 }; 1513 #ifdef VNODE_OP_NOINLINE 1514 int 1515 VOP_PATHCONF(vp, name, retval) 1516 struct vnode *vp; 1517 int name; 1518 register_t *retval; 1519 { 1520 struct vop_pathconf_args a; 1521 #ifdef VNODE_LOCKDEBUG 1522 int islocked_vp; 1523 #endif 1524 a.a_desc = VDESC(vop_pathconf); 1525 a.a_vp = vp; 1526 #ifdef VNODE_LOCKDEBUG 1527 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1528 if (islocked_vp != 1) 1529 panic("vop_pathconf: vp: locked %d, expected %d", islocked_vp, 1); 1530 #endif 1531 a.a_name = name; 1532 a.a_retval = retval; 1533 return (VCALL(vp, VOFFSET(vop_pathconf), &a)); 1534 } 1535 #endif 1536 1537 const int vop_advlock_vp_offsets[] = { 1538 VOPARG_OFFSETOF(struct vop_advlock_args,a_vp), 1539 VDESC_NO_OFFSET 1540 }; 1541 const struct vnodeop_desc vop_advlock_desc = { 1542 38, 1543 "vop_advlock", 1544 0, 1545 vop_advlock_vp_offsets, 1546 VDESC_NO_OFFSET, 1547 VDESC_NO_OFFSET, 1548 VDESC_NO_OFFSET, 1549 VDESC_NO_OFFSET, 1550 NULL, 1551 }; 1552 #ifdef VNODE_OP_NOINLINE 1553 int 1554 VOP_ADVLOCK(vp, id, op, fl, flags) 1555 struct vnode *vp; 1556 void *id; 1557 int op; 1558 struct flock *fl; 1559 int flags; 1560 { 1561 struct vop_advlock_args a; 1562 #ifdef VNODE_LOCKDEBUG 1563 int islocked_vp; 1564 #endif 1565 a.a_desc = VDESC(vop_advlock); 1566 a.a_vp = vp; 1567 #ifdef VNODE_LOCKDEBUG 1568 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0; 1569 if (islocked_vp != 0) 1570 panic("vop_advlock: vp: locked %d, expected %d", islocked_vp, 0); 1571 #endif 1572 a.a_id = id; 1573 a.a_op = op; 1574 a.a_fl = fl; 1575 a.a_flags = flags; 1576 return (VCALL(vp, VOFFSET(vop_advlock), &a)); 1577 } 1578 #endif 1579 1580 const int vop_blkatoff_vp_offsets[] = { 1581 VOPARG_OFFSETOF(struct vop_blkatoff_args,a_vp), 1582 VDESC_NO_OFFSET 1583 }; 1584 const struct vnodeop_desc vop_blkatoff_desc = { 1585 39, 1586 "vop_blkatoff", 1587 0, 1588 vop_blkatoff_vp_offsets, 1589 VDESC_NO_OFFSET, 1590 VDESC_NO_OFFSET, 1591 VDESC_NO_OFFSET, 1592 VDESC_NO_OFFSET, 1593 NULL, 1594 }; 1595 #ifdef VNODE_OP_NOINLINE 1596 int 1597 VOP_BLKATOFF(vp, offset, res, bpp) 1598 struct vnode *vp; 1599 off_t offset; 1600 char **res; 1601 struct buf **bpp; 1602 { 1603 struct vop_blkatoff_args a; 1604 #ifdef VNODE_LOCKDEBUG 1605 int islocked_vp; 1606 #endif 1607 a.a_desc = VDESC(vop_blkatoff); 1608 a.a_vp = vp; 1609 #ifdef VNODE_LOCKDEBUG 1610 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1611 if (islocked_vp != 1) 1612 panic("vop_blkatoff: vp: locked %d, expected %d", islocked_vp, 1); 1613 #endif 1614 a.a_offset = offset; 1615 a.a_res = res; 1616 a.a_bpp = bpp; 1617 return (VCALL(vp, VOFFSET(vop_blkatoff), &a)); 1618 } 1619 #endif 1620 1621 const int vop_valloc_vp_offsets[] = { 1622 VOPARG_OFFSETOF(struct vop_valloc_args,a_pvp), 1623 VDESC_NO_OFFSET 1624 }; 1625 const struct vnodeop_desc vop_valloc_desc = { 1626 40, 1627 "vop_valloc", 1628 0, 1629 vop_valloc_vp_offsets, 1630 VOPARG_OFFSETOF(struct vop_valloc_args, a_vpp), 1631 VOPARG_OFFSETOF(struct vop_valloc_args, a_cred), 1632 VDESC_NO_OFFSET, 1633 VDESC_NO_OFFSET, 1634 NULL, 1635 }; 1636 #ifdef VNODE_OP_NOINLINE 1637 int 1638 VOP_VALLOC(pvp, mode, cred, vpp) 1639 struct vnode *pvp; 1640 int mode; 1641 struct ucred *cred; 1642 struct vnode **vpp; 1643 { 1644 struct vop_valloc_args a; 1645 #ifdef VNODE_LOCKDEBUG 1646 int islocked_pvp; 1647 #endif 1648 a.a_desc = VDESC(vop_valloc); 1649 a.a_pvp = pvp; 1650 #ifdef VNODE_LOCKDEBUG 1651 islocked_pvp = (pvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(pvp) == LK_EXCLUSIVE) : 1; 1652 if (islocked_pvp != 1) 1653 panic("vop_valloc: pvp: locked %d, expected %d", islocked_pvp, 1); 1654 #endif 1655 a.a_mode = mode; 1656 a.a_cred = cred; 1657 a.a_vpp = vpp; 1658 return (VCALL(pvp, VOFFSET(vop_valloc), &a)); 1659 } 1660 #endif 1661 1662 const int vop_balloc_vp_offsets[] = { 1663 VOPARG_OFFSETOF(struct vop_balloc_args,a_vp), 1664 VDESC_NO_OFFSET 1665 }; 1666 const struct vnodeop_desc vop_balloc_desc = { 1667 41, 1668 "vop_balloc", 1669 0, 1670 vop_balloc_vp_offsets, 1671 VDESC_NO_OFFSET, 1672 VOPARG_OFFSETOF(struct vop_balloc_args, a_cred), 1673 VDESC_NO_OFFSET, 1674 VDESC_NO_OFFSET, 1675 NULL, 1676 }; 1677 #ifdef VNODE_OP_NOINLINE 1678 int 1679 VOP_BALLOC(vp, startoffset, size, cred, flags, bpp) 1680 struct vnode *vp; 1681 off_t startoffset; 1682 int size; 1683 struct ucred *cred; 1684 int flags; 1685 struct buf **bpp; 1686 { 1687 struct vop_balloc_args a; 1688 #ifdef VNODE_LOCKDEBUG 1689 int islocked_vp; 1690 #endif 1691 a.a_desc = VDESC(vop_balloc); 1692 a.a_vp = vp; 1693 #ifdef VNODE_LOCKDEBUG 1694 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1695 if (islocked_vp != 1) 1696 panic("vop_balloc: vp: locked %d, expected %d", islocked_vp, 1); 1697 #endif 1698 a.a_startoffset = startoffset; 1699 a.a_size = size; 1700 a.a_cred = cred; 1701 a.a_flags = flags; 1702 a.a_bpp = bpp; 1703 return (VCALL(vp, VOFFSET(vop_balloc), &a)); 1704 } 1705 #endif 1706 1707 const int vop_reallocblks_vp_offsets[] = { 1708 VOPARG_OFFSETOF(struct vop_reallocblks_args,a_vp), 1709 VDESC_NO_OFFSET 1710 }; 1711 const struct vnodeop_desc vop_reallocblks_desc = { 1712 42, 1713 "vop_reallocblks", 1714 0, 1715 vop_reallocblks_vp_offsets, 1716 VDESC_NO_OFFSET, 1717 VDESC_NO_OFFSET, 1718 VDESC_NO_OFFSET, 1719 VDESC_NO_OFFSET, 1720 NULL, 1721 }; 1722 #ifdef VNODE_OP_NOINLINE 1723 int 1724 VOP_REALLOCBLKS(vp, buflist) 1725 struct vnode *vp; 1726 struct cluster_save *buflist; 1727 { 1728 struct vop_reallocblks_args a; 1729 #ifdef VNODE_LOCKDEBUG 1730 int islocked_vp; 1731 #endif 1732 a.a_desc = VDESC(vop_reallocblks); 1733 a.a_vp = vp; 1734 #ifdef VNODE_LOCKDEBUG 1735 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1736 if (islocked_vp != 1) 1737 panic("vop_reallocblks: vp: locked %d, expected %d", islocked_vp, 1); 1738 #endif 1739 a.a_buflist = buflist; 1740 return (VCALL(vp, VOFFSET(vop_reallocblks), &a)); 1741 } 1742 #endif 1743 1744 const int vop_vfree_vp_offsets[] = { 1745 VOPARG_OFFSETOF(struct vop_vfree_args,a_pvp), 1746 VDESC_NO_OFFSET 1747 }; 1748 const struct vnodeop_desc vop_vfree_desc = { 1749 43, 1750 "vop_vfree", 1751 0, 1752 vop_vfree_vp_offsets, 1753 VDESC_NO_OFFSET, 1754 VDESC_NO_OFFSET, 1755 VDESC_NO_OFFSET, 1756 VDESC_NO_OFFSET, 1757 NULL, 1758 }; 1759 #ifdef VNODE_OP_NOINLINE 1760 int 1761 VOP_VFREE(pvp, ino, mode) 1762 struct vnode *pvp; 1763 ino_t ino; 1764 int mode; 1765 { 1766 struct vop_vfree_args a; 1767 #ifdef VNODE_LOCKDEBUG 1768 int islocked_pvp; 1769 #endif 1770 a.a_desc = VDESC(vop_vfree); 1771 a.a_pvp = pvp; 1772 #ifdef VNODE_LOCKDEBUG 1773 islocked_pvp = (pvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(pvp) == LK_EXCLUSIVE) : 1; 1774 if (islocked_pvp != 1) 1775 panic("vop_vfree: pvp: locked %d, expected %d", islocked_pvp, 1); 1776 #endif 1777 a.a_ino = ino; 1778 a.a_mode = mode; 1779 return (VCALL(pvp, VOFFSET(vop_vfree), &a)); 1780 } 1781 #endif 1782 1783 const int vop_truncate_vp_offsets[] = { 1784 VOPARG_OFFSETOF(struct vop_truncate_args,a_vp), 1785 VDESC_NO_OFFSET 1786 }; 1787 const struct vnodeop_desc vop_truncate_desc = { 1788 44, 1789 "vop_truncate", 1790 0, 1791 vop_truncate_vp_offsets, 1792 VDESC_NO_OFFSET, 1793 VOPARG_OFFSETOF(struct vop_truncate_args, a_cred), 1794 VOPARG_OFFSETOF(struct vop_truncate_args, a_p), 1795 VDESC_NO_OFFSET, 1796 NULL, 1797 }; 1798 #ifdef VNODE_OP_NOINLINE 1799 int 1800 VOP_TRUNCATE(vp, length, flags, cred, p) 1801 struct vnode *vp; 1802 off_t length; 1803 int flags; 1804 struct ucred *cred; 1805 struct proc *p; 1806 { 1807 struct vop_truncate_args a; 1808 #ifdef VNODE_LOCKDEBUG 1809 int islocked_vp; 1810 #endif 1811 a.a_desc = VDESC(vop_truncate); 1812 a.a_vp = vp; 1813 #ifdef VNODE_LOCKDEBUG 1814 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1815 if (islocked_vp != 1) 1816 panic("vop_truncate: vp: locked %d, expected %d", islocked_vp, 1); 1817 #endif 1818 a.a_length = length; 1819 a.a_flags = flags; 1820 a.a_cred = cred; 1821 a.a_p = p; 1822 return (VCALL(vp, VOFFSET(vop_truncate), &a)); 1823 } 1824 #endif 1825 1826 const int vop_update_vp_offsets[] = { 1827 VOPARG_OFFSETOF(struct vop_update_args,a_vp), 1828 VDESC_NO_OFFSET 1829 }; 1830 const struct vnodeop_desc vop_update_desc = { 1831 45, 1832 "vop_update", 1833 0, 1834 vop_update_vp_offsets, 1835 VDESC_NO_OFFSET, 1836 VDESC_NO_OFFSET, 1837 VDESC_NO_OFFSET, 1838 VDESC_NO_OFFSET, 1839 NULL, 1840 }; 1841 #ifdef VNODE_OP_NOINLINE 1842 int 1843 VOP_UPDATE(vp, access, modify, flags) 1844 struct vnode *vp; 1845 struct timespec *access; 1846 struct timespec *modify; 1847 int flags; 1848 { 1849 struct vop_update_args a; 1850 #ifdef VNODE_LOCKDEBUG 1851 int islocked_vp; 1852 #endif 1853 a.a_desc = VDESC(vop_update); 1854 a.a_vp = vp; 1855 #ifdef VNODE_LOCKDEBUG 1856 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1857 if (islocked_vp != 1) 1858 panic("vop_update: vp: locked %d, expected %d", islocked_vp, 1); 1859 #endif 1860 a.a_access = access; 1861 a.a_modify = modify; 1862 a.a_flags = flags; 1863 return (VCALL(vp, VOFFSET(vop_update), &a)); 1864 } 1865 #endif 1866 1867 const int vop_lease_vp_offsets[] = { 1868 VOPARG_OFFSETOF(struct vop_lease_args,a_vp), 1869 VDESC_NO_OFFSET 1870 }; 1871 const struct vnodeop_desc vop_lease_desc = { 1872 46, 1873 "vop_lease", 1874 0, 1875 vop_lease_vp_offsets, 1876 VDESC_NO_OFFSET, 1877 VOPARG_OFFSETOF(struct vop_lease_args, a_cred), 1878 VOPARG_OFFSETOF(struct vop_lease_args, a_p), 1879 VDESC_NO_OFFSET, 1880 NULL, 1881 }; 1882 #ifdef VNODE_OP_NOINLINE 1883 int 1884 VOP_LEASE(vp, p, cred, flag) 1885 struct vnode *vp; 1886 struct proc *p; 1887 struct ucred *cred; 1888 int flag; 1889 { 1890 struct vop_lease_args a; 1891 #ifdef VNODE_LOCKDEBUG 1892 #endif 1893 a.a_desc = VDESC(vop_lease); 1894 a.a_vp = vp; 1895 a.a_p = p; 1896 a.a_cred = cred; 1897 a.a_flag = flag; 1898 return (VCALL(vp, VOFFSET(vop_lease), &a)); 1899 } 1900 #endif 1901 1902 const int vop_whiteout_vp_offsets[] = { 1903 VOPARG_OFFSETOF(struct vop_whiteout_args,a_dvp), 1904 VDESC_NO_OFFSET 1905 }; 1906 const struct vnodeop_desc vop_whiteout_desc = { 1907 47, 1908 "vop_whiteout", 1909 0, 1910 vop_whiteout_vp_offsets, 1911 VDESC_NO_OFFSET, 1912 VDESC_NO_OFFSET, 1913 VDESC_NO_OFFSET, 1914 VOPARG_OFFSETOF(struct vop_whiteout_args, a_cnp), 1915 NULL, 1916 }; 1917 #ifdef VNODE_OP_NOINLINE 1918 int 1919 VOP_WHITEOUT(dvp, cnp, flags) 1920 struct vnode *dvp; 1921 struct componentname *cnp; 1922 int flags; 1923 { 1924 struct vop_whiteout_args a; 1925 #ifdef VNODE_LOCKDEBUG 1926 int islocked_dvp; 1927 #endif 1928 a.a_desc = VDESC(vop_whiteout); 1929 a.a_dvp = dvp; 1930 #ifdef VNODE_LOCKDEBUG 1931 islocked_dvp = (dvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1; 1932 if (islocked_dvp != 1) 1933 panic("vop_whiteout: dvp: locked %d, expected %d", islocked_dvp, 1); 1934 #endif 1935 a.a_cnp = cnp; 1936 a.a_flags = flags; 1937 return (VCALL(dvp, VOFFSET(vop_whiteout), &a)); 1938 } 1939 #endif 1940 1941 const int vop_getpages_vp_offsets[] = { 1942 VOPARG_OFFSETOF(struct vop_getpages_args,a_vp), 1943 VDESC_NO_OFFSET 1944 }; 1945 const struct vnodeop_desc vop_getpages_desc = { 1946 48, 1947 "vop_getpages", 1948 0, 1949 vop_getpages_vp_offsets, 1950 VDESC_NO_OFFSET, 1951 VDESC_NO_OFFSET, 1952 VDESC_NO_OFFSET, 1953 VDESC_NO_OFFSET, 1954 NULL, 1955 }; 1956 #ifdef VNODE_OP_NOINLINE 1957 int 1958 VOP_GETPAGES(vp, offset, m, count, centeridx, access_type, advice, flags) 1959 struct vnode *vp; 1960 voff_t offset; 1961 struct vm_page **m; 1962 int *count; 1963 int centeridx; 1964 vm_prot_t access_type; 1965 int advice; 1966 int flags; 1967 { 1968 struct vop_getpages_args a; 1969 #ifdef VNODE_LOCKDEBUG 1970 #endif 1971 a.a_desc = VDESC(vop_getpages); 1972 a.a_vp = vp; 1973 a.a_offset = offset; 1974 a.a_m = m; 1975 a.a_count = count; 1976 a.a_centeridx = centeridx; 1977 a.a_access_type = access_type; 1978 a.a_advice = advice; 1979 a.a_flags = flags; 1980 return (VCALL(vp, VOFFSET(vop_getpages), &a)); 1981 } 1982 #endif 1983 1984 const int vop_putpages_vp_offsets[] = { 1985 VOPARG_OFFSETOF(struct vop_putpages_args,a_vp), 1986 VDESC_NO_OFFSET 1987 }; 1988 const struct vnodeop_desc vop_putpages_desc = { 1989 49, 1990 "vop_putpages", 1991 0, 1992 vop_putpages_vp_offsets, 1993 VDESC_NO_OFFSET, 1994 VDESC_NO_OFFSET, 1995 VDESC_NO_OFFSET, 1996 VDESC_NO_OFFSET, 1997 NULL, 1998 }; 1999 #ifdef VNODE_OP_NOINLINE 2000 int 2001 VOP_PUTPAGES(vp, offlo, offhi, flags) 2002 struct vnode *vp; 2003 voff_t offlo; 2004 voff_t offhi; 2005 int flags; 2006 { 2007 struct vop_putpages_args a; 2008 #ifdef VNODE_LOCKDEBUG 2009 #endif 2010 a.a_desc = VDESC(vop_putpages); 2011 a.a_vp = vp; 2012 a.a_offlo = offlo; 2013 a.a_offhi = offhi; 2014 a.a_flags = flags; 2015 return (VCALL(vp, VOFFSET(vop_putpages), &a)); 2016 } 2017 #endif 2018 2019 const int vop_closeextattr_vp_offsets[] = { 2020 VOPARG_OFFSETOF(struct vop_closeextattr_args,a_vp), 2021 VDESC_NO_OFFSET 2022 }; 2023 const struct vnodeop_desc vop_closeextattr_desc = { 2024 50, 2025 "vop_closeextattr", 2026 0, 2027 vop_closeextattr_vp_offsets, 2028 VDESC_NO_OFFSET, 2029 VOPARG_OFFSETOF(struct vop_closeextattr_args, a_cred), 2030 VOPARG_OFFSETOF(struct vop_closeextattr_args, a_p), 2031 VDESC_NO_OFFSET, 2032 NULL, 2033 }; 2034 #ifdef VNODE_OP_NOINLINE 2035 int 2036 VOP_CLOSEEXTATTR(vp, commit, cred, p) 2037 struct vnode *vp; 2038 int commit; 2039 struct ucred *cred; 2040 struct proc *p; 2041 { 2042 struct vop_closeextattr_args a; 2043 #ifdef VNODE_LOCKDEBUG 2044 int islocked_vp; 2045 #endif 2046 a.a_desc = VDESC(vop_closeextattr); 2047 a.a_vp = vp; 2048 #ifdef VNODE_LOCKDEBUG 2049 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 2050 if (islocked_vp != 1) 2051 panic("vop_closeextattr: vp: locked %d, expected %d", islocked_vp, 1); 2052 #endif 2053 a.a_commit = commit; 2054 a.a_cred = cred; 2055 a.a_p = p; 2056 return (VCALL(vp, VOFFSET(vop_closeextattr), &a)); 2057 } 2058 #endif 2059 2060 const int vop_getextattr_vp_offsets[] = { 2061 VOPARG_OFFSETOF(struct vop_getextattr_args,a_vp), 2062 VDESC_NO_OFFSET 2063 }; 2064 const struct vnodeop_desc vop_getextattr_desc = { 2065 51, 2066 "vop_getextattr", 2067 0, 2068 vop_getextattr_vp_offsets, 2069 VDESC_NO_OFFSET, 2070 VOPARG_OFFSETOF(struct vop_getextattr_args, a_cred), 2071 VOPARG_OFFSETOF(struct vop_getextattr_args, a_p), 2072 VDESC_NO_OFFSET, 2073 NULL, 2074 }; 2075 #ifdef VNODE_OP_NOINLINE 2076 int 2077 VOP_GETEXTATTR(vp, attrnamespace, name, uio, size, cred, p) 2078 struct vnode *vp; 2079 int attrnamespace; 2080 const char *name; 2081 struct uio *uio; 2082 size_t *size; 2083 struct ucred *cred; 2084 struct proc *p; 2085 { 2086 struct vop_getextattr_args a; 2087 #ifdef VNODE_LOCKDEBUG 2088 int islocked_vp; 2089 #endif 2090 a.a_desc = VDESC(vop_getextattr); 2091 a.a_vp = vp; 2092 #ifdef VNODE_LOCKDEBUG 2093 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 2094 if (islocked_vp != 1) 2095 panic("vop_getextattr: vp: locked %d, expected %d", islocked_vp, 1); 2096 #endif 2097 a.a_attrnamespace = attrnamespace; 2098 a.a_name = name; 2099 a.a_uio = uio; 2100 a.a_size = size; 2101 a.a_cred = cred; 2102 a.a_p = p; 2103 return (VCALL(vp, VOFFSET(vop_getextattr), &a)); 2104 } 2105 #endif 2106 2107 const int vop_listextattr_vp_offsets[] = { 2108 VOPARG_OFFSETOF(struct vop_listextattr_args,a_vp), 2109 VDESC_NO_OFFSET 2110 }; 2111 const struct vnodeop_desc vop_listextattr_desc = { 2112 52, 2113 "vop_listextattr", 2114 0, 2115 vop_listextattr_vp_offsets, 2116 VDESC_NO_OFFSET, 2117 VOPARG_OFFSETOF(struct vop_listextattr_args, a_cred), 2118 VOPARG_OFFSETOF(struct vop_listextattr_args, a_p), 2119 VDESC_NO_OFFSET, 2120 NULL, 2121 }; 2122 #ifdef VNODE_OP_NOINLINE 2123 int 2124 VOP_LISTEXTATTR(vp, attrnamespace, uio, size, cred, p) 2125 struct vnode *vp; 2126 int attrnamespace; 2127 struct uio *uio; 2128 size_t *size; 2129 struct ucred *cred; 2130 struct proc *p; 2131 { 2132 struct vop_listextattr_args a; 2133 #ifdef VNODE_LOCKDEBUG 2134 int islocked_vp; 2135 #endif 2136 a.a_desc = VDESC(vop_listextattr); 2137 a.a_vp = vp; 2138 #ifdef VNODE_LOCKDEBUG 2139 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 2140 if (islocked_vp != 1) 2141 panic("vop_listextattr: vp: locked %d, expected %d", islocked_vp, 1); 2142 #endif 2143 a.a_attrnamespace = attrnamespace; 2144 a.a_uio = uio; 2145 a.a_size = size; 2146 a.a_cred = cred; 2147 a.a_p = p; 2148 return (VCALL(vp, VOFFSET(vop_listextattr), &a)); 2149 } 2150 #endif 2151 2152 const int vop_openextattr_vp_offsets[] = { 2153 VOPARG_OFFSETOF(struct vop_openextattr_args,a_vp), 2154 VDESC_NO_OFFSET 2155 }; 2156 const struct vnodeop_desc vop_openextattr_desc = { 2157 53, 2158 "vop_openextattr", 2159 0, 2160 vop_openextattr_vp_offsets, 2161 VDESC_NO_OFFSET, 2162 VOPARG_OFFSETOF(struct vop_openextattr_args, a_cred), 2163 VOPARG_OFFSETOF(struct vop_openextattr_args, a_p), 2164 VDESC_NO_OFFSET, 2165 NULL, 2166 }; 2167 #ifdef VNODE_OP_NOINLINE 2168 int 2169 VOP_OPENEXTATTR(vp, cred, p) 2170 struct vnode *vp; 2171 struct ucred *cred; 2172 struct proc *p; 2173 { 2174 struct vop_openextattr_args a; 2175 #ifdef VNODE_LOCKDEBUG 2176 int islocked_vp; 2177 #endif 2178 a.a_desc = VDESC(vop_openextattr); 2179 a.a_vp = vp; 2180 #ifdef VNODE_LOCKDEBUG 2181 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 2182 if (islocked_vp != 1) 2183 panic("vop_openextattr: vp: locked %d, expected %d", islocked_vp, 1); 2184 #endif 2185 a.a_cred = cred; 2186 a.a_p = p; 2187 return (VCALL(vp, VOFFSET(vop_openextattr), &a)); 2188 } 2189 #endif 2190 2191 const int vop_deleteextattr_vp_offsets[] = { 2192 VOPARG_OFFSETOF(struct vop_deleteextattr_args,a_vp), 2193 VDESC_NO_OFFSET 2194 }; 2195 const struct vnodeop_desc vop_deleteextattr_desc = { 2196 54, 2197 "vop_deleteextattr", 2198 0, 2199 vop_deleteextattr_vp_offsets, 2200 VDESC_NO_OFFSET, 2201 VOPARG_OFFSETOF(struct vop_deleteextattr_args, a_cred), 2202 VOPARG_OFFSETOF(struct vop_deleteextattr_args, a_p), 2203 VDESC_NO_OFFSET, 2204 NULL, 2205 }; 2206 #ifdef VNODE_OP_NOINLINE 2207 int 2208 VOP_DELETEEXTATTR(vp, attrnamespace, name, cred, p) 2209 struct vnode *vp; 2210 int attrnamespace; 2211 const char *name; 2212 struct ucred *cred; 2213 struct proc *p; 2214 { 2215 struct vop_deleteextattr_args a; 2216 #ifdef VNODE_LOCKDEBUG 2217 int islocked_vp; 2218 #endif 2219 a.a_desc = VDESC(vop_deleteextattr); 2220 a.a_vp = vp; 2221 #ifdef VNODE_LOCKDEBUG 2222 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 2223 if (islocked_vp != 1) 2224 panic("vop_deleteextattr: vp: locked %d, expected %d", islocked_vp, 1); 2225 #endif 2226 a.a_attrnamespace = attrnamespace; 2227 a.a_name = name; 2228 a.a_cred = cred; 2229 a.a_p = p; 2230 return (VCALL(vp, VOFFSET(vop_deleteextattr), &a)); 2231 } 2232 #endif 2233 2234 const int vop_setextattr_vp_offsets[] = { 2235 VOPARG_OFFSETOF(struct vop_setextattr_args,a_vp), 2236 VDESC_NO_OFFSET 2237 }; 2238 const struct vnodeop_desc vop_setextattr_desc = { 2239 55, 2240 "vop_setextattr", 2241 0, 2242 vop_setextattr_vp_offsets, 2243 VDESC_NO_OFFSET, 2244 VOPARG_OFFSETOF(struct vop_setextattr_args, a_cred), 2245 VOPARG_OFFSETOF(struct vop_setextattr_args, a_p), 2246 VDESC_NO_OFFSET, 2247 NULL, 2248 }; 2249 #ifdef VNODE_OP_NOINLINE 2250 int 2251 VOP_SETEXTATTR(vp, attrnamespace, name, uio, cred, p) 2252 struct vnode *vp; 2253 int attrnamespace; 2254 const char *name; 2255 struct uio *uio; 2256 struct ucred *cred; 2257 struct proc *p; 2258 { 2259 struct vop_setextattr_args a; 2260 #ifdef VNODE_LOCKDEBUG 2261 int islocked_vp; 2262 #endif 2263 a.a_desc = VDESC(vop_setextattr); 2264 a.a_vp = vp; 2265 #ifdef VNODE_LOCKDEBUG 2266 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 2267 if (islocked_vp != 1) 2268 panic("vop_setextattr: vp: locked %d, expected %d", islocked_vp, 1); 2269 #endif 2270 a.a_attrnamespace = attrnamespace; 2271 a.a_name = name; 2272 a.a_uio = uio; 2273 a.a_cred = cred; 2274 a.a_p = p; 2275 return (VCALL(vp, VOFFSET(vop_setextattr), &a)); 2276 } 2277 #endif 2278 2279 /* End of special cases. */ 2280 2281 const struct vnodeop_desc * const vfs_op_descs[] = { 2282 &vop_default_desc, /* MUST BE FIRST */ 2283 &vop_bwrite_desc, /* XXX: SPECIAL CASE */ 2284 2285 &vop_lookup_desc, 2286 &vop_create_desc, 2287 &vop_mknod_desc, 2288 &vop_open_desc, 2289 &vop_close_desc, 2290 &vop_access_desc, 2291 &vop_getattr_desc, 2292 &vop_setattr_desc, 2293 &vop_read_desc, 2294 &vop_write_desc, 2295 &vop_ioctl_desc, 2296 &vop_fcntl_desc, 2297 &vop_poll_desc, 2298 &vop_kqfilter_desc, 2299 &vop_revoke_desc, 2300 &vop_mmap_desc, 2301 &vop_fsync_desc, 2302 &vop_seek_desc, 2303 &vop_remove_desc, 2304 &vop_link_desc, 2305 &vop_rename_desc, 2306 &vop_mkdir_desc, 2307 &vop_rmdir_desc, 2308 &vop_symlink_desc, 2309 &vop_readdir_desc, 2310 &vop_readlink_desc, 2311 &vop_abortop_desc, 2312 &vop_inactive_desc, 2313 &vop_reclaim_desc, 2314 &vop_lock_desc, 2315 &vop_unlock_desc, 2316 &vop_bmap_desc, 2317 &vop_strategy_desc, 2318 &vop_print_desc, 2319 &vop_islocked_desc, 2320 &vop_pathconf_desc, 2321 &vop_advlock_desc, 2322 &vop_blkatoff_desc, 2323 &vop_valloc_desc, 2324 &vop_balloc_desc, 2325 &vop_reallocblks_desc, 2326 &vop_vfree_desc, 2327 &vop_truncate_desc, 2328 &vop_update_desc, 2329 &vop_lease_desc, 2330 &vop_whiteout_desc, 2331 &vop_getpages_desc, 2332 &vop_putpages_desc, 2333 &vop_closeextattr_desc, 2334 &vop_getextattr_desc, 2335 &vop_listextattr_desc, 2336 &vop_openextattr_desc, 2337 &vop_deleteextattr_desc, 2338 &vop_setextattr_desc, 2339 NULL 2340 }; 2341 2342
Indexes created Sun Sep 21 20:09:37 GMT 2025