vnode_if.c revision 1.69
1 /* $NetBSD: vnode_if.c,v 1.69 2007/07/22 21:27:49 pooka 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.53 2007/07/22 21:26:53 pooka Exp 9 * by the script: 10 * NetBSD: vnode_if.sh,v 1.44 2007/07/22 21:26:53 pooka 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.69 2007/07/22 21:27:49 pooka 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 #include "opt_vnode_lockdebug.h" 51 52 #include <sys/param.h> 53 #include <sys/mount.h> 54 #include <sys/buf.h> 55 #include <sys/vnode.h> 56 57 const struct vnodeop_desc vop_default_desc = { 58 0, 59 "default", 60 0, 61 NULL, 62 VDESC_NO_OFFSET, 63 VDESC_NO_OFFSET, 64 VDESC_NO_OFFSET, 65 VDESC_NO_OFFSET, 66 NULL, 67 }; 68 69 70 /* Special cases: */ 71 72 const int vop_bwrite_vp_offsets[] = { 73 VDESC_NO_OFFSET 74 }; 75 const struct vnodeop_desc vop_bwrite_desc = { 76 VOP_BWRITE_DESCOFFSET, 77 "vop_bwrite", 78 0, 79 vop_bwrite_vp_offsets, 80 VDESC_NO_OFFSET, 81 VDESC_NO_OFFSET, 82 VDESC_NO_OFFSET, 83 VDESC_NO_OFFSET, 84 NULL, 85 }; 86 int 87 VOP_BWRITE(struct buf *bp) 88 { 89 struct vop_bwrite_args a; 90 int rv; 91 #ifdef VNODE_LOCKDEBUG 92 #endif 93 a.a_desc = VDESC(vop_bwrite); 94 a.a_bp = bp; 95 96 rv = VCALL(bp->b_vp, VOFFSET(vop_bwrite), &a); 97 return (rv); 98 } 99 100 /* End of special cases */ 101 102 const int vop_lookup_vp_offsets[] = { 103 VOPARG_OFFSETOF(struct vop_lookup_args,a_dvp), 104 VDESC_NO_OFFSET 105 }; 106 const struct vnodeop_desc vop_lookup_desc = { 107 VOP_LOOKUP_DESCOFFSET, 108 "vop_lookup", 109 0, 110 vop_lookup_vp_offsets, 111 VOPARG_OFFSETOF(struct vop_lookup_args, a_vpp), 112 VDESC_NO_OFFSET, 113 VDESC_NO_OFFSET, 114 VOPARG_OFFSETOF(struct vop_lookup_args, a_cnp), 115 NULL, 116 }; 117 int 118 VOP_LOOKUP(struct vnode *dvp, 119 struct vnode **vpp, 120 struct componentname *cnp) 121 { 122 struct vop_lookup_args a; 123 int rv; 124 #ifdef VNODE_LOCKDEBUG 125 #endif 126 a.a_desc = VDESC(vop_lookup); 127 a.a_dvp = dvp; 128 a.a_vpp = vpp; 129 a.a_cnp = cnp; 130 131 rv = VCALL(dvp, VOFFSET(vop_lookup), &a); 132 #ifdef DIAGNOSTIC 133 if (rv == 0) 134 KASSERT((*vpp)->v_size != VSIZENOTSET 135 && (*vpp)->v_writesize != VSIZENOTSET); 136 #endif /* DIAGNOSTIC */ 137 return (rv); 138 } 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 VOP_CREATE_DESCOFFSET, 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 int 156 VOP_CREATE(struct vnode *dvp, 157 struct vnode **vpp, 158 struct componentname *cnp, 159 struct vattr *vap) 160 { 161 struct vop_create_args a; 162 int rv; 163 #ifdef VNODE_LOCKDEBUG 164 int islocked_dvp; 165 #endif 166 a.a_desc = VDESC(vop_create); 167 a.a_dvp = dvp; 168 #ifdef VNODE_LOCKDEBUG 169 islocked_dvp = (dvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1; 170 if (islocked_dvp != 1) 171 panic("vop_create: dvp: locked %d, expected %d", islocked_dvp, 1); 172 #endif 173 a.a_vpp = vpp; 174 a.a_cnp = cnp; 175 a.a_vap = vap; 176 177 rv = VCALL(dvp, VOFFSET(vop_create), &a); 178 #ifdef DIAGNOSTIC 179 if (rv == 0) 180 KASSERT((*vpp)->v_size != VSIZENOTSET 181 && (*vpp)->v_writesize != VSIZENOTSET); 182 #endif /* DIAGNOSTIC */ 183 return (rv); 184 } 185 186 const int vop_mknod_vp_offsets[] = { 187 VOPARG_OFFSETOF(struct vop_mknod_args,a_dvp), 188 VDESC_NO_OFFSET 189 }; 190 const struct vnodeop_desc vop_mknod_desc = { 191 VOP_MKNOD_DESCOFFSET, 192 "vop_mknod", 193 0 | VDESC_VP0_WILLPUT, 194 vop_mknod_vp_offsets, 195 VOPARG_OFFSETOF(struct vop_mknod_args, a_vpp), 196 VDESC_NO_OFFSET, 197 VDESC_NO_OFFSET, 198 VOPARG_OFFSETOF(struct vop_mknod_args, a_cnp), 199 NULL, 200 }; 201 int 202 VOP_MKNOD(struct vnode *dvp, 203 struct vnode **vpp, 204 struct componentname *cnp, 205 struct vattr *vap) 206 { 207 struct vop_mknod_args a; 208 int rv; 209 #ifdef VNODE_LOCKDEBUG 210 int islocked_dvp; 211 #endif 212 a.a_desc = VDESC(vop_mknod); 213 a.a_dvp = dvp; 214 #ifdef VNODE_LOCKDEBUG 215 islocked_dvp = (dvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1; 216 if (islocked_dvp != 1) 217 panic("vop_mknod: dvp: locked %d, expected %d", islocked_dvp, 1); 218 #endif 219 a.a_vpp = vpp; 220 a.a_cnp = cnp; 221 a.a_vap = vap; 222 223 rv = VCALL(dvp, VOFFSET(vop_mknod), &a); 224 #ifdef DIAGNOSTIC 225 if (rv == 0) 226 KASSERT((*vpp)->v_size != VSIZENOTSET 227 && (*vpp)->v_writesize != VSIZENOTSET); 228 #endif /* DIAGNOSTIC */ 229 return (rv); 230 } 231 232 const int vop_open_vp_offsets[] = { 233 VOPARG_OFFSETOF(struct vop_open_args,a_vp), 234 VDESC_NO_OFFSET 235 }; 236 const struct vnodeop_desc vop_open_desc = { 237 VOP_OPEN_DESCOFFSET, 238 "vop_open", 239 0, 240 vop_open_vp_offsets, 241 VDESC_NO_OFFSET, 242 VOPARG_OFFSETOF(struct vop_open_args, a_cred), 243 VOPARG_OFFSETOF(struct vop_open_args, a_l), 244 VDESC_NO_OFFSET, 245 NULL, 246 }; 247 int 248 VOP_OPEN(struct vnode *vp, 249 int mode, 250 kauth_cred_t cred, 251 struct lwp *l) 252 { 253 struct vop_open_args a; 254 int rv; 255 #ifdef VNODE_LOCKDEBUG 256 int islocked_vp; 257 #endif 258 a.a_desc = VDESC(vop_open); 259 a.a_vp = vp; 260 #ifdef VNODE_LOCKDEBUG 261 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 262 if (islocked_vp != 1) 263 panic("vop_open: vp: locked %d, expected %d", islocked_vp, 1); 264 #endif 265 a.a_mode = mode; 266 a.a_cred = cred; 267 a.a_l = l; 268 269 rv = VCALL(vp, VOFFSET(vop_open), &a); 270 return (rv); 271 } 272 273 const int vop_close_vp_offsets[] = { 274 VOPARG_OFFSETOF(struct vop_close_args,a_vp), 275 VDESC_NO_OFFSET 276 }; 277 const struct vnodeop_desc vop_close_desc = { 278 VOP_CLOSE_DESCOFFSET, 279 "vop_close", 280 0, 281 vop_close_vp_offsets, 282 VDESC_NO_OFFSET, 283 VOPARG_OFFSETOF(struct vop_close_args, a_cred), 284 VOPARG_OFFSETOF(struct vop_close_args, a_l), 285 VDESC_NO_OFFSET, 286 NULL, 287 }; 288 int 289 VOP_CLOSE(struct vnode *vp, 290 int fflag, 291 kauth_cred_t cred, 292 struct lwp *l) 293 { 294 struct vop_close_args a; 295 int rv; 296 #ifdef VNODE_LOCKDEBUG 297 int islocked_vp; 298 #endif 299 a.a_desc = VDESC(vop_close); 300 a.a_vp = vp; 301 #ifdef VNODE_LOCKDEBUG 302 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 303 if (islocked_vp != 1) 304 panic("vop_close: vp: locked %d, expected %d", islocked_vp, 1); 305 #endif 306 a.a_fflag = fflag; 307 a.a_cred = cred; 308 a.a_l = l; 309 310 rv = VCALL(vp, VOFFSET(vop_close), &a); 311 return (rv); 312 } 313 314 const int vop_access_vp_offsets[] = { 315 VOPARG_OFFSETOF(struct vop_access_args,a_vp), 316 VDESC_NO_OFFSET 317 }; 318 const struct vnodeop_desc vop_access_desc = { 319 VOP_ACCESS_DESCOFFSET, 320 "vop_access", 321 0, 322 vop_access_vp_offsets, 323 VDESC_NO_OFFSET, 324 VOPARG_OFFSETOF(struct vop_access_args, a_cred), 325 VOPARG_OFFSETOF(struct vop_access_args, a_l), 326 VDESC_NO_OFFSET, 327 NULL, 328 }; 329 int 330 VOP_ACCESS(struct vnode *vp, 331 int mode, 332 kauth_cred_t cred, 333 struct lwp *l) 334 { 335 struct vop_access_args a; 336 int rv; 337 #ifdef VNODE_LOCKDEBUG 338 int islocked_vp; 339 #endif 340 a.a_desc = VDESC(vop_access); 341 a.a_vp = vp; 342 #ifdef VNODE_LOCKDEBUG 343 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 344 if (islocked_vp != 1) 345 panic("vop_access: vp: locked %d, expected %d", islocked_vp, 1); 346 #endif 347 a.a_mode = mode; 348 a.a_cred = cred; 349 a.a_l = l; 350 351 rv = VCALL(vp, VOFFSET(vop_access), &a); 352 return (rv); 353 } 354 355 const int vop_getattr_vp_offsets[] = { 356 VOPARG_OFFSETOF(struct vop_getattr_args,a_vp), 357 VDESC_NO_OFFSET 358 }; 359 const struct vnodeop_desc vop_getattr_desc = { 360 VOP_GETATTR_DESCOFFSET, 361 "vop_getattr", 362 0, 363 vop_getattr_vp_offsets, 364 VDESC_NO_OFFSET, 365 VOPARG_OFFSETOF(struct vop_getattr_args, a_cred), 366 VOPARG_OFFSETOF(struct vop_getattr_args, a_l), 367 VDESC_NO_OFFSET, 368 NULL, 369 }; 370 int 371 VOP_GETATTR(struct vnode *vp, 372 struct vattr *vap, 373 kauth_cred_t cred, 374 struct lwp *l) 375 { 376 struct vop_getattr_args a; 377 int rv; 378 #ifdef VNODE_LOCKDEBUG 379 #endif 380 a.a_desc = VDESC(vop_getattr); 381 a.a_vp = vp; 382 a.a_vap = vap; 383 a.a_cred = cred; 384 a.a_l = l; 385 386 rv = VCALL(vp, VOFFSET(vop_getattr), &a); 387 return (rv); 388 } 389 390 const int vop_setattr_vp_offsets[] = { 391 VOPARG_OFFSETOF(struct vop_setattr_args,a_vp), 392 VDESC_NO_OFFSET 393 }; 394 const struct vnodeop_desc vop_setattr_desc = { 395 VOP_SETATTR_DESCOFFSET, 396 "vop_setattr", 397 0, 398 vop_setattr_vp_offsets, 399 VDESC_NO_OFFSET, 400 VOPARG_OFFSETOF(struct vop_setattr_args, a_cred), 401 VOPARG_OFFSETOF(struct vop_setattr_args, a_l), 402 VDESC_NO_OFFSET, 403 NULL, 404 }; 405 int 406 VOP_SETATTR(struct vnode *vp, 407 struct vattr *vap, 408 kauth_cred_t cred, 409 struct lwp *l) 410 { 411 struct vop_setattr_args a; 412 int rv; 413 #ifdef VNODE_LOCKDEBUG 414 int islocked_vp; 415 #endif 416 a.a_desc = VDESC(vop_setattr); 417 a.a_vp = vp; 418 #ifdef VNODE_LOCKDEBUG 419 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 420 if (islocked_vp != 1) 421 panic("vop_setattr: vp: locked %d, expected %d", islocked_vp, 1); 422 #endif 423 a.a_vap = vap; 424 a.a_cred = cred; 425 a.a_l = l; 426 427 rv = VCALL(vp, VOFFSET(vop_setattr), &a); 428 return (rv); 429 } 430 431 const int vop_read_vp_offsets[] = { 432 VOPARG_OFFSETOF(struct vop_read_args,a_vp), 433 VDESC_NO_OFFSET 434 }; 435 const struct vnodeop_desc vop_read_desc = { 436 VOP_READ_DESCOFFSET, 437 "vop_read", 438 0, 439 vop_read_vp_offsets, 440 VDESC_NO_OFFSET, 441 VOPARG_OFFSETOF(struct vop_read_args, a_cred), 442 VDESC_NO_OFFSET, 443 VDESC_NO_OFFSET, 444 NULL, 445 }; 446 int 447 VOP_READ(struct vnode *vp, 448 struct uio *uio, 449 int ioflag, 450 kauth_cred_t cred) 451 { 452 struct vop_read_args a; 453 int rv; 454 #ifdef VNODE_LOCKDEBUG 455 int islocked_vp; 456 #endif 457 a.a_desc = VDESC(vop_read); 458 a.a_vp = vp; 459 #ifdef VNODE_LOCKDEBUG 460 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 461 if (islocked_vp != 1) 462 panic("vop_read: vp: locked %d, expected %d", islocked_vp, 1); 463 #endif 464 a.a_uio = uio; 465 a.a_ioflag = ioflag; 466 a.a_cred = cred; 467 468 rv = VCALL(vp, VOFFSET(vop_read), &a); 469 return (rv); 470 } 471 472 const int vop_write_vp_offsets[] = { 473 VOPARG_OFFSETOF(struct vop_write_args,a_vp), 474 VDESC_NO_OFFSET 475 }; 476 const struct vnodeop_desc vop_write_desc = { 477 VOP_WRITE_DESCOFFSET, 478 "vop_write", 479 0, 480 vop_write_vp_offsets, 481 VDESC_NO_OFFSET, 482 VOPARG_OFFSETOF(struct vop_write_args, a_cred), 483 VDESC_NO_OFFSET, 484 VDESC_NO_OFFSET, 485 NULL, 486 }; 487 int 488 VOP_WRITE(struct vnode *vp, 489 struct uio *uio, 490 int ioflag, 491 kauth_cred_t cred) 492 { 493 struct vop_write_args a; 494 int rv; 495 #ifdef VNODE_LOCKDEBUG 496 int islocked_vp; 497 #endif 498 a.a_desc = VDESC(vop_write); 499 a.a_vp = vp; 500 #ifdef VNODE_LOCKDEBUG 501 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 502 if (islocked_vp != 1) 503 panic("vop_write: vp: locked %d, expected %d", islocked_vp, 1); 504 #endif 505 a.a_uio = uio; 506 a.a_ioflag = ioflag; 507 a.a_cred = cred; 508 509 rv = VCALL(vp, VOFFSET(vop_write), &a); 510 return (rv); 511 } 512 513 const int vop_ioctl_vp_offsets[] = { 514 VOPARG_OFFSETOF(struct vop_ioctl_args,a_vp), 515 VDESC_NO_OFFSET 516 }; 517 const struct vnodeop_desc vop_ioctl_desc = { 518 VOP_IOCTL_DESCOFFSET, 519 "vop_ioctl", 520 0, 521 vop_ioctl_vp_offsets, 522 VDESC_NO_OFFSET, 523 VOPARG_OFFSETOF(struct vop_ioctl_args, a_cred), 524 VOPARG_OFFSETOF(struct vop_ioctl_args, a_l), 525 VDESC_NO_OFFSET, 526 NULL, 527 }; 528 int 529 VOP_IOCTL(struct vnode *vp, 530 u_long command, 531 void *data, 532 int fflag, 533 kauth_cred_t cred, 534 struct lwp *l) 535 { 536 struct vop_ioctl_args a; 537 int rv; 538 #ifdef VNODE_LOCKDEBUG 539 int islocked_vp; 540 #endif 541 a.a_desc = VDESC(vop_ioctl); 542 a.a_vp = vp; 543 #ifdef VNODE_LOCKDEBUG 544 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0; 545 if (islocked_vp != 0) 546 panic("vop_ioctl: vp: locked %d, expected %d", islocked_vp, 0); 547 #endif 548 a.a_command = command; 549 a.a_data = data; 550 a.a_fflag = fflag; 551 a.a_cred = cred; 552 a.a_l = l; 553 554 rv = VCALL(vp, VOFFSET(vop_ioctl), &a); 555 return (rv); 556 } 557 558 const int vop_fcntl_vp_offsets[] = { 559 VOPARG_OFFSETOF(struct vop_fcntl_args,a_vp), 560 VDESC_NO_OFFSET 561 }; 562 const struct vnodeop_desc vop_fcntl_desc = { 563 VOP_FCNTL_DESCOFFSET, 564 "vop_fcntl", 565 0, 566 vop_fcntl_vp_offsets, 567 VDESC_NO_OFFSET, 568 VOPARG_OFFSETOF(struct vop_fcntl_args, a_cred), 569 VOPARG_OFFSETOF(struct vop_fcntl_args, a_l), 570 VDESC_NO_OFFSET, 571 NULL, 572 }; 573 int 574 VOP_FCNTL(struct vnode *vp, 575 u_int command, 576 void *data, 577 int fflag, 578 kauth_cred_t cred, 579 struct lwp *l) 580 { 581 struct vop_fcntl_args a; 582 int rv; 583 #ifdef VNODE_LOCKDEBUG 584 int islocked_vp; 585 #endif 586 a.a_desc = VDESC(vop_fcntl); 587 a.a_vp = vp; 588 #ifdef VNODE_LOCKDEBUG 589 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0; 590 if (islocked_vp != 0) 591 panic("vop_fcntl: vp: locked %d, expected %d", islocked_vp, 0); 592 #endif 593 a.a_command = command; 594 a.a_data = data; 595 a.a_fflag = fflag; 596 a.a_cred = cred; 597 a.a_l = l; 598 599 rv = VCALL(vp, VOFFSET(vop_fcntl), &a); 600 return (rv); 601 } 602 603 const int vop_poll_vp_offsets[] = { 604 VOPARG_OFFSETOF(struct vop_poll_args,a_vp), 605 VDESC_NO_OFFSET 606 }; 607 const struct vnodeop_desc vop_poll_desc = { 608 VOP_POLL_DESCOFFSET, 609 "vop_poll", 610 0, 611 vop_poll_vp_offsets, 612 VDESC_NO_OFFSET, 613 VDESC_NO_OFFSET, 614 VOPARG_OFFSETOF(struct vop_poll_args, a_l), 615 VDESC_NO_OFFSET, 616 NULL, 617 }; 618 int 619 VOP_POLL(struct vnode *vp, 620 int events, 621 struct lwp *l) 622 { 623 struct vop_poll_args a; 624 int rv; 625 #ifdef VNODE_LOCKDEBUG 626 int islocked_vp; 627 #endif 628 a.a_desc = VDESC(vop_poll); 629 a.a_vp = vp; 630 #ifdef VNODE_LOCKDEBUG 631 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0; 632 if (islocked_vp != 0) 633 panic("vop_poll: vp: locked %d, expected %d", islocked_vp, 0); 634 #endif 635 a.a_events = events; 636 a.a_l = l; 637 638 rv = VCALL(vp, VOFFSET(vop_poll), &a); 639 return (rv); 640 } 641 642 const int vop_kqfilter_vp_offsets[] = { 643 VOPARG_OFFSETOF(struct vop_kqfilter_args,a_vp), 644 VDESC_NO_OFFSET 645 }; 646 const struct vnodeop_desc vop_kqfilter_desc = { 647 VOP_KQFILTER_DESCOFFSET, 648 "vop_kqfilter", 649 0, 650 vop_kqfilter_vp_offsets, 651 VDESC_NO_OFFSET, 652 VDESC_NO_OFFSET, 653 VDESC_NO_OFFSET, 654 VDESC_NO_OFFSET, 655 NULL, 656 }; 657 int 658 VOP_KQFILTER(struct vnode *vp, 659 struct knote *kn) 660 { 661 struct vop_kqfilter_args a; 662 int rv; 663 #ifdef VNODE_LOCKDEBUG 664 int islocked_vp; 665 #endif 666 a.a_desc = VDESC(vop_kqfilter); 667 a.a_vp = vp; 668 #ifdef VNODE_LOCKDEBUG 669 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0; 670 if (islocked_vp != 0) 671 panic("vop_kqfilter: vp: locked %d, expected %d", islocked_vp, 0); 672 #endif 673 a.a_kn = kn; 674 675 rv = VCALL(vp, VOFFSET(vop_kqfilter), &a); 676 return (rv); 677 } 678 679 const int vop_revoke_vp_offsets[] = { 680 VOPARG_OFFSETOF(struct vop_revoke_args,a_vp), 681 VDESC_NO_OFFSET 682 }; 683 const struct vnodeop_desc vop_revoke_desc = { 684 VOP_REVOKE_DESCOFFSET, 685 "vop_revoke", 686 0, 687 vop_revoke_vp_offsets, 688 VDESC_NO_OFFSET, 689 VDESC_NO_OFFSET, 690 VDESC_NO_OFFSET, 691 VDESC_NO_OFFSET, 692 NULL, 693 }; 694 int 695 VOP_REVOKE(struct vnode *vp, 696 int flags) 697 { 698 struct vop_revoke_args a; 699 int rv; 700 #ifdef VNODE_LOCKDEBUG 701 int islocked_vp; 702 #endif 703 a.a_desc = VDESC(vop_revoke); 704 a.a_vp = vp; 705 #ifdef VNODE_LOCKDEBUG 706 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0; 707 if (islocked_vp != 0) 708 panic("vop_revoke: vp: locked %d, expected %d", islocked_vp, 0); 709 #endif 710 a.a_flags = flags; 711 712 rv = VCALL(vp, VOFFSET(vop_revoke), &a); 713 return (rv); 714 } 715 716 const int vop_mmap_vp_offsets[] = { 717 VOPARG_OFFSETOF(struct vop_mmap_args,a_vp), 718 VDESC_NO_OFFSET 719 }; 720 const struct vnodeop_desc vop_mmap_desc = { 721 VOP_MMAP_DESCOFFSET, 722 "vop_mmap", 723 0, 724 vop_mmap_vp_offsets, 725 VDESC_NO_OFFSET, 726 VOPARG_OFFSETOF(struct vop_mmap_args, a_cred), 727 VOPARG_OFFSETOF(struct vop_mmap_args, a_l), 728 VDESC_NO_OFFSET, 729 NULL, 730 }; 731 int 732 VOP_MMAP(struct vnode *vp, 733 int fflags, 734 kauth_cred_t cred, 735 struct lwp *l) 736 { 737 struct vop_mmap_args a; 738 int rv; 739 #ifdef VNODE_LOCKDEBUG 740 #endif 741 a.a_desc = VDESC(vop_mmap); 742 a.a_vp = vp; 743 a.a_fflags = fflags; 744 a.a_cred = cred; 745 a.a_l = l; 746 747 rv = VCALL(vp, VOFFSET(vop_mmap), &a); 748 return (rv); 749 } 750 751 const int vop_fsync_vp_offsets[] = { 752 VOPARG_OFFSETOF(struct vop_fsync_args,a_vp), 753 VDESC_NO_OFFSET 754 }; 755 const struct vnodeop_desc vop_fsync_desc = { 756 VOP_FSYNC_DESCOFFSET, 757 "vop_fsync", 758 0, 759 vop_fsync_vp_offsets, 760 VDESC_NO_OFFSET, 761 VOPARG_OFFSETOF(struct vop_fsync_args, a_cred), 762 VOPARG_OFFSETOF(struct vop_fsync_args, a_l), 763 VDESC_NO_OFFSET, 764 NULL, 765 }; 766 int 767 VOP_FSYNC(struct vnode *vp, 768 kauth_cred_t cred, 769 int flags, 770 off_t offlo, 771 off_t offhi, 772 struct lwp *l) 773 { 774 struct vop_fsync_args a; 775 int rv; 776 #ifdef VNODE_LOCKDEBUG 777 int islocked_vp; 778 #endif 779 a.a_desc = VDESC(vop_fsync); 780 a.a_vp = vp; 781 #ifdef VNODE_LOCKDEBUG 782 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 783 if (islocked_vp != 1) 784 panic("vop_fsync: vp: locked %d, expected %d", islocked_vp, 1); 785 #endif 786 a.a_cred = cred; 787 a.a_flags = flags; 788 a.a_offlo = offlo; 789 a.a_offhi = offhi; 790 a.a_l = l; 791 792 rv = VCALL(vp, VOFFSET(vop_fsync), &a); 793 return (rv); 794 } 795 796 const int vop_seek_vp_offsets[] = { 797 VOPARG_OFFSETOF(struct vop_seek_args,a_vp), 798 VDESC_NO_OFFSET 799 }; 800 const struct vnodeop_desc vop_seek_desc = { 801 VOP_SEEK_DESCOFFSET, 802 "vop_seek", 803 0, 804 vop_seek_vp_offsets, 805 VDESC_NO_OFFSET, 806 VOPARG_OFFSETOF(struct vop_seek_args, a_cred), 807 VDESC_NO_OFFSET, 808 VDESC_NO_OFFSET, 809 NULL, 810 }; 811 int 812 VOP_SEEK(struct vnode *vp, 813 off_t oldoff, 814 off_t newoff, 815 kauth_cred_t cred) 816 { 817 struct vop_seek_args a; 818 int rv; 819 #ifdef VNODE_LOCKDEBUG 820 #endif 821 a.a_desc = VDESC(vop_seek); 822 a.a_vp = vp; 823 a.a_oldoff = oldoff; 824 a.a_newoff = newoff; 825 a.a_cred = cred; 826 827 rv = VCALL(vp, VOFFSET(vop_seek), &a); 828 return (rv); 829 } 830 831 const int vop_remove_vp_offsets[] = { 832 VOPARG_OFFSETOF(struct vop_remove_args,a_dvp), 833 VOPARG_OFFSETOF(struct vop_remove_args,a_vp), 834 VDESC_NO_OFFSET 835 }; 836 const struct vnodeop_desc vop_remove_desc = { 837 VOP_REMOVE_DESCOFFSET, 838 "vop_remove", 839 0 | VDESC_VP0_WILLPUT | VDESC_VP1_WILLPUT, 840 vop_remove_vp_offsets, 841 VDESC_NO_OFFSET, 842 VDESC_NO_OFFSET, 843 VDESC_NO_OFFSET, 844 VOPARG_OFFSETOF(struct vop_remove_args, a_cnp), 845 NULL, 846 }; 847 int 848 VOP_REMOVE(struct vnode *dvp, 849 struct vnode *vp, 850 struct componentname *cnp) 851 { 852 struct vop_remove_args a; 853 int rv; 854 #ifdef VNODE_LOCKDEBUG 855 int islocked_dvp; 856 int islocked_vp; 857 #endif 858 a.a_desc = VDESC(vop_remove); 859 a.a_dvp = dvp; 860 #ifdef VNODE_LOCKDEBUG 861 islocked_dvp = (dvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1; 862 if (islocked_dvp != 1) 863 panic("vop_remove: dvp: locked %d, expected %d", islocked_dvp, 1); 864 #endif 865 a.a_vp = vp; 866 #ifdef VNODE_LOCKDEBUG 867 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 868 if (islocked_vp != 1) 869 panic("vop_remove: vp: locked %d, expected %d", islocked_vp, 1); 870 #endif 871 a.a_cnp = cnp; 872 873 rv = VCALL(dvp, VOFFSET(vop_remove), &a); 874 return (rv); 875 } 876 877 const int vop_link_vp_offsets[] = { 878 VOPARG_OFFSETOF(struct vop_link_args,a_dvp), 879 VOPARG_OFFSETOF(struct vop_link_args,a_vp), 880 VDESC_NO_OFFSET 881 }; 882 const struct vnodeop_desc vop_link_desc = { 883 VOP_LINK_DESCOFFSET, 884 "vop_link", 885 0 | VDESC_VP0_WILLPUT, 886 vop_link_vp_offsets, 887 VDESC_NO_OFFSET, 888 VDESC_NO_OFFSET, 889 VDESC_NO_OFFSET, 890 VOPARG_OFFSETOF(struct vop_link_args, a_cnp), 891 NULL, 892 }; 893 int 894 VOP_LINK(struct vnode *dvp, 895 struct vnode *vp, 896 struct componentname *cnp) 897 { 898 struct vop_link_args a; 899 int rv; 900 #ifdef VNODE_LOCKDEBUG 901 int islocked_dvp; 902 int islocked_vp; 903 #endif 904 a.a_desc = VDESC(vop_link); 905 a.a_dvp = dvp; 906 #ifdef VNODE_LOCKDEBUG 907 islocked_dvp = (dvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1; 908 if (islocked_dvp != 1) 909 panic("vop_link: dvp: locked %d, expected %d", islocked_dvp, 1); 910 #endif 911 a.a_vp = vp; 912 #ifdef VNODE_LOCKDEBUG 913 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0; 914 if (islocked_vp != 0) 915 panic("vop_link: vp: locked %d, expected %d", islocked_vp, 0); 916 #endif 917 a.a_cnp = cnp; 918 919 rv = VCALL(dvp, VOFFSET(vop_link), &a); 920 return (rv); 921 } 922 923 const int vop_rename_vp_offsets[] = { 924 VOPARG_OFFSETOF(struct vop_rename_args,a_fdvp), 925 VOPARG_OFFSETOF(struct vop_rename_args,a_fvp), 926 VOPARG_OFFSETOF(struct vop_rename_args,a_tdvp), 927 VOPARG_OFFSETOF(struct vop_rename_args,a_tvp), 928 VDESC_NO_OFFSET 929 }; 930 const struct vnodeop_desc vop_rename_desc = { 931 VOP_RENAME_DESCOFFSET, 932 "vop_rename", 933 0 | VDESC_VP0_WILLRELE | VDESC_VP1_WILLRELE | VDESC_VP2_WILLPUT | VDESC_VP3_WILLPUT, 934 vop_rename_vp_offsets, 935 VDESC_NO_OFFSET, 936 VDESC_NO_OFFSET, 937 VDESC_NO_OFFSET, 938 VOPARG_OFFSETOF(struct vop_rename_args, a_fcnp), 939 NULL, 940 }; 941 int 942 VOP_RENAME(struct vnode *fdvp, 943 struct vnode *fvp, 944 struct componentname *fcnp, 945 struct vnode *tdvp, 946 struct vnode *tvp, 947 struct componentname *tcnp) 948 { 949 struct vop_rename_args a; 950 int rv; 951 #ifdef VNODE_LOCKDEBUG 952 int islocked_fdvp; 953 int islocked_fvp; 954 int islocked_tdvp; 955 #endif 956 a.a_desc = VDESC(vop_rename); 957 a.a_fdvp = fdvp; 958 #ifdef VNODE_LOCKDEBUG 959 islocked_fdvp = (fdvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(fdvp) == LK_EXCLUSIVE) : 0; 960 if (islocked_fdvp != 0) 961 panic("vop_rename: fdvp: locked %d, expected %d", islocked_fdvp, 0); 962 #endif 963 a.a_fvp = fvp; 964 #ifdef VNODE_LOCKDEBUG 965 islocked_fvp = (fvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(fvp) == LK_EXCLUSIVE) : 0; 966 if (islocked_fvp != 0) 967 panic("vop_rename: fvp: locked %d, expected %d", islocked_fvp, 0); 968 #endif 969 a.a_fcnp = fcnp; 970 a.a_tdvp = tdvp; 971 #ifdef VNODE_LOCKDEBUG 972 islocked_tdvp = (tdvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(tdvp) == LK_EXCLUSIVE) : 1; 973 if (islocked_tdvp != 1) 974 panic("vop_rename: tdvp: locked %d, expected %d", islocked_tdvp, 1); 975 #endif 976 a.a_tvp = tvp; 977 a.a_tcnp = tcnp; 978 979 rv = VCALL(fdvp, VOFFSET(vop_rename), &a); 980 return (rv); 981 } 982 983 const int vop_mkdir_vp_offsets[] = { 984 VOPARG_OFFSETOF(struct vop_mkdir_args,a_dvp), 985 VDESC_NO_OFFSET 986 }; 987 const struct vnodeop_desc vop_mkdir_desc = { 988 VOP_MKDIR_DESCOFFSET, 989 "vop_mkdir", 990 0 | VDESC_VP0_WILLPUT, 991 vop_mkdir_vp_offsets, 992 VOPARG_OFFSETOF(struct vop_mkdir_args, a_vpp), 993 VDESC_NO_OFFSET, 994 VDESC_NO_OFFSET, 995 VOPARG_OFFSETOF(struct vop_mkdir_args, a_cnp), 996 NULL, 997 }; 998 int 999 VOP_MKDIR(struct vnode *dvp, 1000 struct vnode **vpp, 1001 struct componentname *cnp, 1002 struct vattr *vap) 1003 { 1004 struct vop_mkdir_args a; 1005 int rv; 1006 #ifdef VNODE_LOCKDEBUG 1007 int islocked_dvp; 1008 #endif 1009 a.a_desc = VDESC(vop_mkdir); 1010 a.a_dvp = dvp; 1011 #ifdef VNODE_LOCKDEBUG 1012 islocked_dvp = (dvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1; 1013 if (islocked_dvp != 1) 1014 panic("vop_mkdir: dvp: locked %d, expected %d", islocked_dvp, 1); 1015 #endif 1016 a.a_vpp = vpp; 1017 a.a_cnp = cnp; 1018 a.a_vap = vap; 1019 1020 rv = VCALL(dvp, VOFFSET(vop_mkdir), &a); 1021 #ifdef DIAGNOSTIC 1022 if (rv == 0) 1023 KASSERT((*vpp)->v_size != VSIZENOTSET 1024 && (*vpp)->v_writesize != VSIZENOTSET); 1025 #endif /* DIAGNOSTIC */ 1026 return (rv); 1027 } 1028 1029 const int vop_rmdir_vp_offsets[] = { 1030 VOPARG_OFFSETOF(struct vop_rmdir_args,a_dvp), 1031 VOPARG_OFFSETOF(struct vop_rmdir_args,a_vp), 1032 VDESC_NO_OFFSET 1033 }; 1034 const struct vnodeop_desc vop_rmdir_desc = { 1035 VOP_RMDIR_DESCOFFSET, 1036 "vop_rmdir", 1037 0 | VDESC_VP0_WILLPUT | VDESC_VP1_WILLPUT, 1038 vop_rmdir_vp_offsets, 1039 VDESC_NO_OFFSET, 1040 VDESC_NO_OFFSET, 1041 VDESC_NO_OFFSET, 1042 VOPARG_OFFSETOF(struct vop_rmdir_args, a_cnp), 1043 NULL, 1044 }; 1045 int 1046 VOP_RMDIR(struct vnode *dvp, 1047 struct vnode *vp, 1048 struct componentname *cnp) 1049 { 1050 struct vop_rmdir_args a; 1051 int rv; 1052 #ifdef VNODE_LOCKDEBUG 1053 int islocked_dvp; 1054 int islocked_vp; 1055 #endif 1056 a.a_desc = VDESC(vop_rmdir); 1057 a.a_dvp = dvp; 1058 #ifdef VNODE_LOCKDEBUG 1059 islocked_dvp = (dvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1; 1060 if (islocked_dvp != 1) 1061 panic("vop_rmdir: dvp: locked %d, expected %d", islocked_dvp, 1); 1062 #endif 1063 a.a_vp = vp; 1064 #ifdef VNODE_LOCKDEBUG 1065 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1066 if (islocked_vp != 1) 1067 panic("vop_rmdir: vp: locked %d, expected %d", islocked_vp, 1); 1068 #endif 1069 a.a_cnp = cnp; 1070 1071 rv = VCALL(dvp, VOFFSET(vop_rmdir), &a); 1072 return (rv); 1073 } 1074 1075 const int vop_symlink_vp_offsets[] = { 1076 VOPARG_OFFSETOF(struct vop_symlink_args,a_dvp), 1077 VDESC_NO_OFFSET 1078 }; 1079 const struct vnodeop_desc vop_symlink_desc = { 1080 VOP_SYMLINK_DESCOFFSET, 1081 "vop_symlink", 1082 0 | VDESC_VP0_WILLPUT, 1083 vop_symlink_vp_offsets, 1084 VOPARG_OFFSETOF(struct vop_symlink_args, a_vpp), 1085 VDESC_NO_OFFSET, 1086 VDESC_NO_OFFSET, 1087 VOPARG_OFFSETOF(struct vop_symlink_args, a_cnp), 1088 NULL, 1089 }; 1090 int 1091 VOP_SYMLINK(struct vnode *dvp, 1092 struct vnode **vpp, 1093 struct componentname *cnp, 1094 struct vattr *vap, 1095 char *target) 1096 { 1097 struct vop_symlink_args a; 1098 int rv; 1099 #ifdef VNODE_LOCKDEBUG 1100 int islocked_dvp; 1101 #endif 1102 a.a_desc = VDESC(vop_symlink); 1103 a.a_dvp = dvp; 1104 #ifdef VNODE_LOCKDEBUG 1105 islocked_dvp = (dvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1; 1106 if (islocked_dvp != 1) 1107 panic("vop_symlink: dvp: locked %d, expected %d", islocked_dvp, 1); 1108 #endif 1109 a.a_vpp = vpp; 1110 a.a_cnp = cnp; 1111 a.a_vap = vap; 1112 a.a_target = target; 1113 1114 rv = VCALL(dvp, VOFFSET(vop_symlink), &a); 1115 #ifdef DIAGNOSTIC 1116 if (rv == 0) 1117 KASSERT((*vpp)->v_size != VSIZENOTSET 1118 && (*vpp)->v_writesize != VSIZENOTSET); 1119 #endif /* DIAGNOSTIC */ 1120 return (rv); 1121 } 1122 1123 const int vop_readdir_vp_offsets[] = { 1124 VOPARG_OFFSETOF(struct vop_readdir_args,a_vp), 1125 VDESC_NO_OFFSET 1126 }; 1127 const struct vnodeop_desc vop_readdir_desc = { 1128 VOP_READDIR_DESCOFFSET, 1129 "vop_readdir", 1130 0, 1131 vop_readdir_vp_offsets, 1132 VDESC_NO_OFFSET, 1133 VOPARG_OFFSETOF(struct vop_readdir_args, a_cred), 1134 VDESC_NO_OFFSET, 1135 VDESC_NO_OFFSET, 1136 NULL, 1137 }; 1138 int 1139 VOP_READDIR(struct vnode *vp, 1140 struct uio *uio, 1141 kauth_cred_t cred, 1142 int *eofflag, 1143 off_t **cookies, 1144 int *ncookies) 1145 { 1146 struct vop_readdir_args a; 1147 int rv; 1148 #ifdef VNODE_LOCKDEBUG 1149 int islocked_vp; 1150 #endif 1151 a.a_desc = VDESC(vop_readdir); 1152 a.a_vp = vp; 1153 #ifdef VNODE_LOCKDEBUG 1154 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1155 if (islocked_vp != 1) 1156 panic("vop_readdir: vp: locked %d, expected %d", islocked_vp, 1); 1157 #endif 1158 a.a_uio = uio; 1159 a.a_cred = cred; 1160 a.a_eofflag = eofflag; 1161 a.a_cookies = cookies; 1162 a.a_ncookies = ncookies; 1163 1164 rv = VCALL(vp, VOFFSET(vop_readdir), &a); 1165 return (rv); 1166 } 1167 1168 const int vop_readlink_vp_offsets[] = { 1169 VOPARG_OFFSETOF(struct vop_readlink_args,a_vp), 1170 VDESC_NO_OFFSET 1171 }; 1172 const struct vnodeop_desc vop_readlink_desc = { 1173 VOP_READLINK_DESCOFFSET, 1174 "vop_readlink", 1175 0, 1176 vop_readlink_vp_offsets, 1177 VDESC_NO_OFFSET, 1178 VOPARG_OFFSETOF(struct vop_readlink_args, a_cred), 1179 VDESC_NO_OFFSET, 1180 VDESC_NO_OFFSET, 1181 NULL, 1182 }; 1183 int 1184 VOP_READLINK(struct vnode *vp, 1185 struct uio *uio, 1186 kauth_cred_t cred) 1187 { 1188 struct vop_readlink_args a; 1189 int rv; 1190 #ifdef VNODE_LOCKDEBUG 1191 int islocked_vp; 1192 #endif 1193 a.a_desc = VDESC(vop_readlink); 1194 a.a_vp = vp; 1195 #ifdef VNODE_LOCKDEBUG 1196 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1197 if (islocked_vp != 1) 1198 panic("vop_readlink: vp: locked %d, expected %d", islocked_vp, 1); 1199 #endif 1200 a.a_uio = uio; 1201 a.a_cred = cred; 1202 1203 rv = VCALL(vp, VOFFSET(vop_readlink), &a); 1204 return (rv); 1205 } 1206 1207 const int vop_abortop_vp_offsets[] = { 1208 VOPARG_OFFSETOF(struct vop_abortop_args,a_dvp), 1209 VDESC_NO_OFFSET 1210 }; 1211 const struct vnodeop_desc vop_abortop_desc = { 1212 VOP_ABORTOP_DESCOFFSET, 1213 "vop_abortop", 1214 0, 1215 vop_abortop_vp_offsets, 1216 VDESC_NO_OFFSET, 1217 VDESC_NO_OFFSET, 1218 VDESC_NO_OFFSET, 1219 VOPARG_OFFSETOF(struct vop_abortop_args, a_cnp), 1220 NULL, 1221 }; 1222 int 1223 VOP_ABORTOP(struct vnode *dvp, 1224 struct componentname *cnp) 1225 { 1226 struct vop_abortop_args a; 1227 int rv; 1228 #ifdef VNODE_LOCKDEBUG 1229 #endif 1230 a.a_desc = VDESC(vop_abortop); 1231 a.a_dvp = dvp; 1232 a.a_cnp = cnp; 1233 1234 rv = VCALL(dvp, VOFFSET(vop_abortop), &a); 1235 return (rv); 1236 } 1237 1238 const int vop_inactive_vp_offsets[] = { 1239 VOPARG_OFFSETOF(struct vop_inactive_args,a_vp), 1240 VDESC_NO_OFFSET 1241 }; 1242 const struct vnodeop_desc vop_inactive_desc = { 1243 VOP_INACTIVE_DESCOFFSET, 1244 "vop_inactive", 1245 0 | VDESC_VP0_WILLUNLOCK, 1246 vop_inactive_vp_offsets, 1247 VDESC_NO_OFFSET, 1248 VDESC_NO_OFFSET, 1249 VOPARG_OFFSETOF(struct vop_inactive_args, a_l), 1250 VDESC_NO_OFFSET, 1251 NULL, 1252 }; 1253 int 1254 VOP_INACTIVE(struct vnode *vp, 1255 struct lwp *l) 1256 { 1257 struct vop_inactive_args a; 1258 int rv; 1259 #ifdef VNODE_LOCKDEBUG 1260 int islocked_vp; 1261 #endif 1262 a.a_desc = VDESC(vop_inactive); 1263 a.a_vp = vp; 1264 #ifdef VNODE_LOCKDEBUG 1265 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1266 if (islocked_vp != 1) 1267 panic("vop_inactive: vp: locked %d, expected %d", islocked_vp, 1); 1268 #endif 1269 a.a_l = l; 1270 1271 rv = VCALL(vp, VOFFSET(vop_inactive), &a); 1272 return (rv); 1273 } 1274 1275 const int vop_reclaim_vp_offsets[] = { 1276 VOPARG_OFFSETOF(struct vop_reclaim_args,a_vp), 1277 VDESC_NO_OFFSET 1278 }; 1279 const struct vnodeop_desc vop_reclaim_desc = { 1280 VOP_RECLAIM_DESCOFFSET, 1281 "vop_reclaim", 1282 0, 1283 vop_reclaim_vp_offsets, 1284 VDESC_NO_OFFSET, 1285 VDESC_NO_OFFSET, 1286 VOPARG_OFFSETOF(struct vop_reclaim_args, a_l), 1287 VDESC_NO_OFFSET, 1288 NULL, 1289 }; 1290 int 1291 VOP_RECLAIM(struct vnode *vp, 1292 struct lwp *l) 1293 { 1294 struct vop_reclaim_args a; 1295 int rv; 1296 #ifdef VNODE_LOCKDEBUG 1297 int islocked_vp; 1298 #endif 1299 a.a_desc = VDESC(vop_reclaim); 1300 a.a_vp = vp; 1301 #ifdef VNODE_LOCKDEBUG 1302 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0; 1303 if (islocked_vp != 0) 1304 panic("vop_reclaim: vp: locked %d, expected %d", islocked_vp, 0); 1305 #endif 1306 a.a_l = l; 1307 1308 rv = VCALL(vp, VOFFSET(vop_reclaim), &a); 1309 return (rv); 1310 } 1311 1312 const int vop_lock_vp_offsets[] = { 1313 VOPARG_OFFSETOF(struct vop_lock_args,a_vp), 1314 VDESC_NO_OFFSET 1315 }; 1316 const struct vnodeop_desc vop_lock_desc = { 1317 VOP_LOCK_DESCOFFSET, 1318 "vop_lock", 1319 0, 1320 vop_lock_vp_offsets, 1321 VDESC_NO_OFFSET, 1322 VDESC_NO_OFFSET, 1323 VDESC_NO_OFFSET, 1324 VDESC_NO_OFFSET, 1325 NULL, 1326 }; 1327 int 1328 VOP_LOCK(struct vnode *vp, 1329 int flags) 1330 { 1331 struct vop_lock_args a; 1332 int rv; 1333 #ifdef VNODE_LOCKDEBUG 1334 int islocked_vp; 1335 #endif 1336 a.a_desc = VDESC(vop_lock); 1337 a.a_vp = vp; 1338 #ifdef VNODE_LOCKDEBUG 1339 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0; 1340 if (islocked_vp != 0) 1341 panic("vop_lock: vp: locked %d, expected %d", islocked_vp, 0); 1342 #endif 1343 a.a_flags = flags; 1344 1345 rv = VCALL(vp, VOFFSET(vop_lock), &a); 1346 return (rv); 1347 } 1348 1349 const int vop_unlock_vp_offsets[] = { 1350 VOPARG_OFFSETOF(struct vop_unlock_args,a_vp), 1351 VDESC_NO_OFFSET 1352 }; 1353 const struct vnodeop_desc vop_unlock_desc = { 1354 VOP_UNLOCK_DESCOFFSET, 1355 "vop_unlock", 1356 0, 1357 vop_unlock_vp_offsets, 1358 VDESC_NO_OFFSET, 1359 VDESC_NO_OFFSET, 1360 VDESC_NO_OFFSET, 1361 VDESC_NO_OFFSET, 1362 NULL, 1363 }; 1364 int 1365 VOP_UNLOCK(struct vnode *vp, 1366 int flags) 1367 { 1368 struct vop_unlock_args a; 1369 int rv; 1370 #ifdef VNODE_LOCKDEBUG 1371 int islocked_vp; 1372 #endif 1373 a.a_desc = VDESC(vop_unlock); 1374 a.a_vp = vp; 1375 #ifdef VNODE_LOCKDEBUG 1376 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1377 if (islocked_vp != 1) 1378 panic("vop_unlock: vp: locked %d, expected %d", islocked_vp, 1); 1379 #endif 1380 a.a_flags = flags; 1381 1382 rv = VCALL(vp, VOFFSET(vop_unlock), &a); 1383 return (rv); 1384 } 1385 1386 const int vop_bmap_vp_offsets[] = { 1387 VOPARG_OFFSETOF(struct vop_bmap_args,a_vp), 1388 VDESC_NO_OFFSET 1389 }; 1390 const struct vnodeop_desc vop_bmap_desc = { 1391 VOP_BMAP_DESCOFFSET, 1392 "vop_bmap", 1393 0, 1394 vop_bmap_vp_offsets, 1395 VOPARG_OFFSETOF(struct vop_bmap_args, a_vpp), 1396 VDESC_NO_OFFSET, 1397 VDESC_NO_OFFSET, 1398 VDESC_NO_OFFSET, 1399 NULL, 1400 }; 1401 int 1402 VOP_BMAP(struct vnode *vp, 1403 daddr_t bn, 1404 struct vnode **vpp, 1405 daddr_t *bnp, 1406 int *runp) 1407 { 1408 struct vop_bmap_args a; 1409 int rv; 1410 #ifdef VNODE_LOCKDEBUG 1411 #endif 1412 a.a_desc = VDESC(vop_bmap); 1413 a.a_vp = vp; 1414 a.a_bn = bn; 1415 a.a_vpp = vpp; 1416 a.a_bnp = bnp; 1417 a.a_runp = runp; 1418 1419 rv = VCALL(vp, VOFFSET(vop_bmap), &a); 1420 return (rv); 1421 } 1422 1423 const int vop_strategy_vp_offsets[] = { 1424 VOPARG_OFFSETOF(struct vop_strategy_args,a_vp), 1425 VDESC_NO_OFFSET 1426 }; 1427 const struct vnodeop_desc vop_strategy_desc = { 1428 VOP_STRATEGY_DESCOFFSET, 1429 "vop_strategy", 1430 0, 1431 vop_strategy_vp_offsets, 1432 VDESC_NO_OFFSET, 1433 VDESC_NO_OFFSET, 1434 VDESC_NO_OFFSET, 1435 VDESC_NO_OFFSET, 1436 NULL, 1437 }; 1438 int 1439 VOP_STRATEGY(struct vnode *vp, 1440 struct buf *bp) 1441 { 1442 struct vop_strategy_args a; 1443 int rv; 1444 #ifdef VNODE_LOCKDEBUG 1445 #endif 1446 a.a_desc = VDESC(vop_strategy); 1447 a.a_vp = vp; 1448 a.a_bp = bp; 1449 1450 rv = VCALL(vp, VOFFSET(vop_strategy), &a); 1451 return (rv); 1452 } 1453 1454 const int vop_print_vp_offsets[] = { 1455 VOPARG_OFFSETOF(struct vop_print_args,a_vp), 1456 VDESC_NO_OFFSET 1457 }; 1458 const struct vnodeop_desc vop_print_desc = { 1459 VOP_PRINT_DESCOFFSET, 1460 "vop_print", 1461 0, 1462 vop_print_vp_offsets, 1463 VDESC_NO_OFFSET, 1464 VDESC_NO_OFFSET, 1465 VDESC_NO_OFFSET, 1466 VDESC_NO_OFFSET, 1467 NULL, 1468 }; 1469 int 1470 VOP_PRINT(struct vnode *vp) 1471 { 1472 struct vop_print_args a; 1473 int rv; 1474 #ifdef VNODE_LOCKDEBUG 1475 #endif 1476 a.a_desc = VDESC(vop_print); 1477 a.a_vp = vp; 1478 1479 rv = VCALL(vp, VOFFSET(vop_print), &a); 1480 return (rv); 1481 } 1482 1483 const int vop_islocked_vp_offsets[] = { 1484 VOPARG_OFFSETOF(struct vop_islocked_args,a_vp), 1485 VDESC_NO_OFFSET 1486 }; 1487 const struct vnodeop_desc vop_islocked_desc = { 1488 VOP_ISLOCKED_DESCOFFSET, 1489 "vop_islocked", 1490 0, 1491 vop_islocked_vp_offsets, 1492 VDESC_NO_OFFSET, 1493 VDESC_NO_OFFSET, 1494 VDESC_NO_OFFSET, 1495 VDESC_NO_OFFSET, 1496 NULL, 1497 }; 1498 int 1499 VOP_ISLOCKED(struct vnode *vp) 1500 { 1501 struct vop_islocked_args a; 1502 int rv; 1503 #ifdef VNODE_LOCKDEBUG 1504 #endif 1505 a.a_desc = VDESC(vop_islocked); 1506 a.a_vp = vp; 1507 1508 rv = VCALL(vp, VOFFSET(vop_islocked), &a); 1509 return (rv); 1510 } 1511 1512 const int vop_pathconf_vp_offsets[] = { 1513 VOPARG_OFFSETOF(struct vop_pathconf_args,a_vp), 1514 VDESC_NO_OFFSET 1515 }; 1516 const struct vnodeop_desc vop_pathconf_desc = { 1517 VOP_PATHCONF_DESCOFFSET, 1518 "vop_pathconf", 1519 0, 1520 vop_pathconf_vp_offsets, 1521 VDESC_NO_OFFSET, 1522 VDESC_NO_OFFSET, 1523 VDESC_NO_OFFSET, 1524 VDESC_NO_OFFSET, 1525 NULL, 1526 }; 1527 int 1528 VOP_PATHCONF(struct vnode *vp, 1529 int name, 1530 register_t *retval) 1531 { 1532 struct vop_pathconf_args a; 1533 int rv; 1534 #ifdef VNODE_LOCKDEBUG 1535 int islocked_vp; 1536 #endif 1537 a.a_desc = VDESC(vop_pathconf); 1538 a.a_vp = vp; 1539 #ifdef VNODE_LOCKDEBUG 1540 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1541 if (islocked_vp != 1) 1542 panic("vop_pathconf: vp: locked %d, expected %d", islocked_vp, 1); 1543 #endif 1544 a.a_name = name; 1545 a.a_retval = retval; 1546 1547 rv = VCALL(vp, VOFFSET(vop_pathconf), &a); 1548 return (rv); 1549 } 1550 1551 const int vop_advlock_vp_offsets[] = { 1552 VOPARG_OFFSETOF(struct vop_advlock_args,a_vp), 1553 VDESC_NO_OFFSET 1554 }; 1555 const struct vnodeop_desc vop_advlock_desc = { 1556 VOP_ADVLOCK_DESCOFFSET, 1557 "vop_advlock", 1558 0, 1559 vop_advlock_vp_offsets, 1560 VDESC_NO_OFFSET, 1561 VDESC_NO_OFFSET, 1562 VDESC_NO_OFFSET, 1563 VDESC_NO_OFFSET, 1564 NULL, 1565 }; 1566 int 1567 VOP_ADVLOCK(struct vnode *vp, 1568 void *id, 1569 int op, 1570 struct flock *fl, 1571 int flags) 1572 { 1573 struct vop_advlock_args a; 1574 int rv; 1575 #ifdef VNODE_LOCKDEBUG 1576 int islocked_vp; 1577 #endif 1578 a.a_desc = VDESC(vop_advlock); 1579 a.a_vp = vp; 1580 #ifdef VNODE_LOCKDEBUG 1581 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0; 1582 if (islocked_vp != 0) 1583 panic("vop_advlock: vp: locked %d, expected %d", islocked_vp, 0); 1584 #endif 1585 a.a_id = id; 1586 a.a_op = op; 1587 a.a_fl = fl; 1588 a.a_flags = flags; 1589 1590 rv = VCALL(vp, VOFFSET(vop_advlock), &a); 1591 return (rv); 1592 } 1593 1594 const int vop_lease_vp_offsets[] = { 1595 VOPARG_OFFSETOF(struct vop_lease_args,a_vp), 1596 VDESC_NO_OFFSET 1597 }; 1598 const struct vnodeop_desc vop_lease_desc = { 1599 VOP_LEASE_DESCOFFSET, 1600 "vop_lease", 1601 0, 1602 vop_lease_vp_offsets, 1603 VDESC_NO_OFFSET, 1604 VOPARG_OFFSETOF(struct vop_lease_args, a_cred), 1605 VOPARG_OFFSETOF(struct vop_lease_args, a_l), 1606 VDESC_NO_OFFSET, 1607 NULL, 1608 }; 1609 int 1610 VOP_LEASE(struct vnode *vp, 1611 struct lwp *l, 1612 kauth_cred_t cred, 1613 int flag) 1614 { 1615 struct vop_lease_args a; 1616 int rv; 1617 #ifdef VNODE_LOCKDEBUG 1618 #endif 1619 a.a_desc = VDESC(vop_lease); 1620 a.a_vp = vp; 1621 a.a_l = l; 1622 a.a_cred = cred; 1623 a.a_flag = flag; 1624 1625 rv = VCALL(vp, VOFFSET(vop_lease), &a); 1626 return (rv); 1627 } 1628 1629 const int vop_whiteout_vp_offsets[] = { 1630 VOPARG_OFFSETOF(struct vop_whiteout_args,a_dvp), 1631 VDESC_NO_OFFSET 1632 }; 1633 const struct vnodeop_desc vop_whiteout_desc = { 1634 VOP_WHITEOUT_DESCOFFSET, 1635 "vop_whiteout", 1636 0, 1637 vop_whiteout_vp_offsets, 1638 VDESC_NO_OFFSET, 1639 VDESC_NO_OFFSET, 1640 VDESC_NO_OFFSET, 1641 VOPARG_OFFSETOF(struct vop_whiteout_args, a_cnp), 1642 NULL, 1643 }; 1644 int 1645 VOP_WHITEOUT(struct vnode *dvp, 1646 struct componentname *cnp, 1647 int flags) 1648 { 1649 struct vop_whiteout_args a; 1650 int rv; 1651 #ifdef VNODE_LOCKDEBUG 1652 int islocked_dvp; 1653 #endif 1654 a.a_desc = VDESC(vop_whiteout); 1655 a.a_dvp = dvp; 1656 #ifdef VNODE_LOCKDEBUG 1657 islocked_dvp = (dvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1; 1658 if (islocked_dvp != 1) 1659 panic("vop_whiteout: dvp: locked %d, expected %d", islocked_dvp, 1); 1660 #endif 1661 a.a_cnp = cnp; 1662 a.a_flags = flags; 1663 1664 rv = VCALL(dvp, VOFFSET(vop_whiteout), &a); 1665 return (rv); 1666 } 1667 1668 const int vop_getpages_vp_offsets[] = { 1669 VOPARG_OFFSETOF(struct vop_getpages_args,a_vp), 1670 VDESC_NO_OFFSET 1671 }; 1672 const struct vnodeop_desc vop_getpages_desc = { 1673 VOP_GETPAGES_DESCOFFSET, 1674 "vop_getpages", 1675 0, 1676 vop_getpages_vp_offsets, 1677 VDESC_NO_OFFSET, 1678 VDESC_NO_OFFSET, 1679 VDESC_NO_OFFSET, 1680 VDESC_NO_OFFSET, 1681 NULL, 1682 }; 1683 int 1684 VOP_GETPAGES(struct vnode *vp, 1685 voff_t offset, 1686 struct vm_page **m, 1687 int *count, 1688 int centeridx, 1689 vm_prot_t access_type, 1690 int advice, 1691 int flags) 1692 { 1693 struct vop_getpages_args a; 1694 int rv; 1695 #ifdef VNODE_LOCKDEBUG 1696 #endif 1697 a.a_desc = VDESC(vop_getpages); 1698 a.a_vp = vp; 1699 a.a_offset = offset; 1700 a.a_m = m; 1701 a.a_count = count; 1702 a.a_centeridx = centeridx; 1703 a.a_access_type = access_type; 1704 a.a_advice = advice; 1705 a.a_flags = flags; 1706 1707 rv = VCALL(vp, VOFFSET(vop_getpages), &a); 1708 return (rv); 1709 } 1710 1711 const int vop_putpages_vp_offsets[] = { 1712 VOPARG_OFFSETOF(struct vop_putpages_args,a_vp), 1713 VDESC_NO_OFFSET 1714 }; 1715 const struct vnodeop_desc vop_putpages_desc = { 1716 VOP_PUTPAGES_DESCOFFSET, 1717 "vop_putpages", 1718 0, 1719 vop_putpages_vp_offsets, 1720 VDESC_NO_OFFSET, 1721 VDESC_NO_OFFSET, 1722 VDESC_NO_OFFSET, 1723 VDESC_NO_OFFSET, 1724 NULL, 1725 }; 1726 int 1727 VOP_PUTPAGES(struct vnode *vp, 1728 voff_t offlo, 1729 voff_t offhi, 1730 int flags) 1731 { 1732 struct vop_putpages_args a; 1733 int rv; 1734 #ifdef VNODE_LOCKDEBUG 1735 #endif 1736 a.a_desc = VDESC(vop_putpages); 1737 a.a_vp = vp; 1738 a.a_offlo = offlo; 1739 a.a_offhi = offhi; 1740 a.a_flags = flags; 1741 1742 rv = VCALL(vp, VOFFSET(vop_putpages), &a); 1743 return (rv); 1744 } 1745 1746 const int vop_closeextattr_vp_offsets[] = { 1747 VOPARG_OFFSETOF(struct vop_closeextattr_args,a_vp), 1748 VDESC_NO_OFFSET 1749 }; 1750 const struct vnodeop_desc vop_closeextattr_desc = { 1751 VOP_CLOSEEXTATTR_DESCOFFSET, 1752 "vop_closeextattr", 1753 0, 1754 vop_closeextattr_vp_offsets, 1755 VDESC_NO_OFFSET, 1756 VOPARG_OFFSETOF(struct vop_closeextattr_args, a_cred), 1757 VOPARG_OFFSETOF(struct vop_closeextattr_args, a_l), 1758 VDESC_NO_OFFSET, 1759 NULL, 1760 }; 1761 int 1762 VOP_CLOSEEXTATTR(struct vnode *vp, 1763 int commit, 1764 kauth_cred_t cred, 1765 struct lwp *l) 1766 { 1767 struct vop_closeextattr_args a; 1768 int rv; 1769 #ifdef VNODE_LOCKDEBUG 1770 int islocked_vp; 1771 #endif 1772 a.a_desc = VDESC(vop_closeextattr); 1773 a.a_vp = vp; 1774 #ifdef VNODE_LOCKDEBUG 1775 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1776 if (islocked_vp != 1) 1777 panic("vop_closeextattr: vp: locked %d, expected %d", islocked_vp, 1); 1778 #endif 1779 a.a_commit = commit; 1780 a.a_cred = cred; 1781 a.a_l = l; 1782 1783 rv = VCALL(vp, VOFFSET(vop_closeextattr), &a); 1784 return (rv); 1785 } 1786 1787 const int vop_getextattr_vp_offsets[] = { 1788 VOPARG_OFFSETOF(struct vop_getextattr_args,a_vp), 1789 VDESC_NO_OFFSET 1790 }; 1791 const struct vnodeop_desc vop_getextattr_desc = { 1792 VOP_GETEXTATTR_DESCOFFSET, 1793 "vop_getextattr", 1794 0, 1795 vop_getextattr_vp_offsets, 1796 VDESC_NO_OFFSET, 1797 VOPARG_OFFSETOF(struct vop_getextattr_args, a_cred), 1798 VOPARG_OFFSETOF(struct vop_getextattr_args, a_l), 1799 VDESC_NO_OFFSET, 1800 NULL, 1801 }; 1802 int 1803 VOP_GETEXTATTR(struct vnode *vp, 1804 int attrnamespace, 1805 const char *name, 1806 struct uio *uio, 1807 size_t *size, 1808 kauth_cred_t cred, 1809 struct lwp *l) 1810 { 1811 struct vop_getextattr_args a; 1812 int rv; 1813 #ifdef VNODE_LOCKDEBUG 1814 int islocked_vp; 1815 #endif 1816 a.a_desc = VDESC(vop_getextattr); 1817 a.a_vp = vp; 1818 #ifdef VNODE_LOCKDEBUG 1819 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1820 if (islocked_vp != 1) 1821 panic("vop_getextattr: vp: locked %d, expected %d", islocked_vp, 1); 1822 #endif 1823 a.a_attrnamespace = attrnamespace; 1824 a.a_name = name; 1825 a.a_uio = uio; 1826 a.a_size = size; 1827 a.a_cred = cred; 1828 a.a_l = l; 1829 1830 rv = VCALL(vp, VOFFSET(vop_getextattr), &a); 1831 return (rv); 1832 } 1833 1834 const int vop_listextattr_vp_offsets[] = { 1835 VOPARG_OFFSETOF(struct vop_listextattr_args,a_vp), 1836 VDESC_NO_OFFSET 1837 }; 1838 const struct vnodeop_desc vop_listextattr_desc = { 1839 VOP_LISTEXTATTR_DESCOFFSET, 1840 "vop_listextattr", 1841 0, 1842 vop_listextattr_vp_offsets, 1843 VDESC_NO_OFFSET, 1844 VOPARG_OFFSETOF(struct vop_listextattr_args, a_cred), 1845 VOPARG_OFFSETOF(struct vop_listextattr_args, a_l), 1846 VDESC_NO_OFFSET, 1847 NULL, 1848 }; 1849 int 1850 VOP_LISTEXTATTR(struct vnode *vp, 1851 int attrnamespace, 1852 struct uio *uio, 1853 size_t *size, 1854 kauth_cred_t cred, 1855 struct lwp *l) 1856 { 1857 struct vop_listextattr_args a; 1858 int rv; 1859 #ifdef VNODE_LOCKDEBUG 1860 int islocked_vp; 1861 #endif 1862 a.a_desc = VDESC(vop_listextattr); 1863 a.a_vp = vp; 1864 #ifdef VNODE_LOCKDEBUG 1865 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1866 if (islocked_vp != 1) 1867 panic("vop_listextattr: vp: locked %d, expected %d", islocked_vp, 1); 1868 #endif 1869 a.a_attrnamespace = attrnamespace; 1870 a.a_uio = uio; 1871 a.a_size = size; 1872 a.a_cred = cred; 1873 a.a_l = l; 1874 1875 rv = VCALL(vp, VOFFSET(vop_listextattr), &a); 1876 return (rv); 1877 } 1878 1879 const int vop_openextattr_vp_offsets[] = { 1880 VOPARG_OFFSETOF(struct vop_openextattr_args,a_vp), 1881 VDESC_NO_OFFSET 1882 }; 1883 const struct vnodeop_desc vop_openextattr_desc = { 1884 VOP_OPENEXTATTR_DESCOFFSET, 1885 "vop_openextattr", 1886 0, 1887 vop_openextattr_vp_offsets, 1888 VDESC_NO_OFFSET, 1889 VOPARG_OFFSETOF(struct vop_openextattr_args, a_cred), 1890 VOPARG_OFFSETOF(struct vop_openextattr_args, a_l), 1891 VDESC_NO_OFFSET, 1892 NULL, 1893 }; 1894 int 1895 VOP_OPENEXTATTR(struct vnode *vp, 1896 kauth_cred_t cred, 1897 struct lwp *l) 1898 { 1899 struct vop_openextattr_args a; 1900 int rv; 1901 #ifdef VNODE_LOCKDEBUG 1902 int islocked_vp; 1903 #endif 1904 a.a_desc = VDESC(vop_openextattr); 1905 a.a_vp = vp; 1906 #ifdef VNODE_LOCKDEBUG 1907 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1908 if (islocked_vp != 1) 1909 panic("vop_openextattr: vp: locked %d, expected %d", islocked_vp, 1); 1910 #endif 1911 a.a_cred = cred; 1912 a.a_l = l; 1913 1914 rv = VCALL(vp, VOFFSET(vop_openextattr), &a); 1915 return (rv); 1916 } 1917 1918 const int vop_deleteextattr_vp_offsets[] = { 1919 VOPARG_OFFSETOF(struct vop_deleteextattr_args,a_vp), 1920 VDESC_NO_OFFSET 1921 }; 1922 const struct vnodeop_desc vop_deleteextattr_desc = { 1923 VOP_DELETEEXTATTR_DESCOFFSET, 1924 "vop_deleteextattr", 1925 0, 1926 vop_deleteextattr_vp_offsets, 1927 VDESC_NO_OFFSET, 1928 VOPARG_OFFSETOF(struct vop_deleteextattr_args, a_cred), 1929 VOPARG_OFFSETOF(struct vop_deleteextattr_args, a_l), 1930 VDESC_NO_OFFSET, 1931 NULL, 1932 }; 1933 int 1934 VOP_DELETEEXTATTR(struct vnode *vp, 1935 int attrnamespace, 1936 const char *name, 1937 kauth_cred_t cred, 1938 struct lwp *l) 1939 { 1940 struct vop_deleteextattr_args a; 1941 int rv; 1942 #ifdef VNODE_LOCKDEBUG 1943 int islocked_vp; 1944 #endif 1945 a.a_desc = VDESC(vop_deleteextattr); 1946 a.a_vp = vp; 1947 #ifdef VNODE_LOCKDEBUG 1948 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1949 if (islocked_vp != 1) 1950 panic("vop_deleteextattr: vp: locked %d, expected %d", islocked_vp, 1); 1951 #endif 1952 a.a_attrnamespace = attrnamespace; 1953 a.a_name = name; 1954 a.a_cred = cred; 1955 a.a_l = l; 1956 1957 rv = VCALL(vp, VOFFSET(vop_deleteextattr), &a); 1958 return (rv); 1959 } 1960 1961 const int vop_setextattr_vp_offsets[] = { 1962 VOPARG_OFFSETOF(struct vop_setextattr_args,a_vp), 1963 VDESC_NO_OFFSET 1964 }; 1965 const struct vnodeop_desc vop_setextattr_desc = { 1966 VOP_SETEXTATTR_DESCOFFSET, 1967 "vop_setextattr", 1968 0, 1969 vop_setextattr_vp_offsets, 1970 VDESC_NO_OFFSET, 1971 VOPARG_OFFSETOF(struct vop_setextattr_args, a_cred), 1972 VOPARG_OFFSETOF(struct vop_setextattr_args, a_l), 1973 VDESC_NO_OFFSET, 1974 NULL, 1975 }; 1976 int 1977 VOP_SETEXTATTR(struct vnode *vp, 1978 int attrnamespace, 1979 const char *name, 1980 struct uio *uio, 1981 kauth_cred_t cred, 1982 struct lwp *l) 1983 { 1984 struct vop_setextattr_args a; 1985 int rv; 1986 #ifdef VNODE_LOCKDEBUG 1987 int islocked_vp; 1988 #endif 1989 a.a_desc = VDESC(vop_setextattr); 1990 a.a_vp = vp; 1991 #ifdef VNODE_LOCKDEBUG 1992 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1993 if (islocked_vp != 1) 1994 panic("vop_setextattr: vp: locked %d, expected %d", islocked_vp, 1); 1995 #endif 1996 a.a_attrnamespace = attrnamespace; 1997 a.a_name = name; 1998 a.a_uio = uio; 1999 a.a_cred = cred; 2000 a.a_l = l; 2001 2002 rv = VCALL(vp, VOFFSET(vop_setextattr), &a); 2003 return (rv); 2004 } 2005 2006 /* End of special cases. */ 2007 2008 const struct vnodeop_desc * const vfs_op_descs[] = { 2009 &vop_default_desc, /* MUST BE FIRST */ 2010 &vop_bwrite_desc, /* XXX: SPECIAL CASE */ 2011 2012 &vop_lookup_desc, 2013 &vop_create_desc, 2014 &vop_mknod_desc, 2015 &vop_open_desc, 2016 &vop_close_desc, 2017 &vop_access_desc, 2018 &vop_getattr_desc, 2019 &vop_setattr_desc, 2020 &vop_read_desc, 2021 &vop_write_desc, 2022 &vop_ioctl_desc, 2023 &vop_fcntl_desc, 2024 &vop_poll_desc, 2025 &vop_kqfilter_desc, 2026 &vop_revoke_desc, 2027 &vop_mmap_desc, 2028 &vop_fsync_desc, 2029 &vop_seek_desc, 2030 &vop_remove_desc, 2031 &vop_link_desc, 2032 &vop_rename_desc, 2033 &vop_mkdir_desc, 2034 &vop_rmdir_desc, 2035 &vop_symlink_desc, 2036 &vop_readdir_desc, 2037 &vop_readlink_desc, 2038 &vop_abortop_desc, 2039 &vop_inactive_desc, 2040 &vop_reclaim_desc, 2041 &vop_lock_desc, 2042 &vop_unlock_desc, 2043 &vop_bmap_desc, 2044 &vop_strategy_desc, 2045 &vop_print_desc, 2046 &vop_islocked_desc, 2047 &vop_pathconf_desc, 2048 &vop_advlock_desc, 2049 &vop_lease_desc, 2050 &vop_whiteout_desc, 2051 &vop_getpages_desc, 2052 &vop_putpages_desc, 2053 &vop_closeextattr_desc, 2054 &vop_getextattr_desc, 2055 &vop_listextattr_desc, 2056 &vop_openextattr_desc, 2057 &vop_deleteextattr_desc, 2058 &vop_setextattr_desc, 2059 NULL 2060 }; 2061 2062
Indexes created Sun Sep 21 16:09:51 GMT 2025