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