vnode_if.c revision 1.66
1 /* $NetBSD: vnode_if.c,v 1.66 2006/07/13 12:00:25 martin 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.50 2006/05/14 21:15:12 elad Exp 9 * by the script: 10 * NetBSD: vnode_if.sh,v 1.42 2006/05/14 21:15:12 elad 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.66 2006/07/13 12:00:25 martin 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_l), 217 VDESC_NO_OFFSET, 218 NULL, 219 }; 220 int 221 VOP_OPEN(struct vnode *vp, 222 int mode, 223 kauth_cred_t cred, 224 struct lwp *l) 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_l = l; 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_l), 255 VDESC_NO_OFFSET, 256 NULL, 257 }; 258 int 259 VOP_CLOSE(struct vnode *vp, 260 int fflag, 261 kauth_cred_t cred, 262 struct lwp *l) 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_l = l; 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_l), 293 VDESC_NO_OFFSET, 294 NULL, 295 }; 296 int 297 VOP_ACCESS(struct vnode *vp, 298 int mode, 299 kauth_cred_t cred, 300 struct lwp *l) 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_l = l; 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_l), 331 VDESC_NO_OFFSET, 332 NULL, 333 }; 334 int 335 VOP_GETATTR(struct vnode *vp, 336 struct vattr *vap, 337 kauth_cred_t cred, 338 struct lwp *l) 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_l = l; 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_l), 363 VDESC_NO_OFFSET, 364 NULL, 365 }; 366 int 367 VOP_SETATTR(struct vnode *vp, 368 struct vattr *vap, 369 kauth_cred_t cred, 370 struct lwp *l) 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_l = l; 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 kauth_cred_t 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 kauth_cred_t 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_l), 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 kauth_cred_t cred, 486 struct lwp *l) 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_l = l; 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_l), 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 kauth_cred_t cred, 528 struct lwp *l) 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) : 0; 538 if (islocked_vp != 0) 539 panic("vop_fcntl: vp: locked %d, expected %d", islocked_vp, 0); 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_l = l; 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_l), 561 VDESC_NO_OFFSET, 562 NULL, 563 }; 564 int 565 VOP_POLL(struct vnode *vp, 566 int events, 567 struct lwp *l) 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_l = l; 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_l), 665 VDESC_NO_OFFSET, 666 NULL, 667 }; 668 int 669 VOP_MMAP(struct vnode *vp, 670 int fflags, 671 kauth_cred_t cred, 672 struct lwp *l) 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_l = l; 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_l), 697 VDESC_NO_OFFSET, 698 NULL, 699 }; 700 int 701 VOP_FSYNC(struct vnode *vp, 702 kauth_cred_t cred, 703 int flags, 704 off_t offlo, 705 off_t offhi, 706 struct lwp *l) 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_l = l; 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 kauth_cred_t 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 kauth_cred_t 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 kauth_cred_t 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_l), 1141 VDESC_NO_OFFSET, 1142 NULL, 1143 }; 1144 int 1145 VOP_INACTIVE(struct vnode *vp, 1146 struct lwp *l) 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_l = l; 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_l), 1175 VDESC_NO_OFFSET, 1176 NULL, 1177 }; 1178 int 1179 VOP_RECLAIM(struct vnode *vp, 1180 struct lwp *l) 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_l = l; 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 #endif 1290 a.a_desc = VDESC(vop_bmap); 1291 a.a_vp = vp; 1292 a.a_bn = bn; 1293 a.a_vpp = vpp; 1294 a.a_bnp = bnp; 1295 a.a_runp = runp; 1296 return (VCALL(vp, VOFFSET(vop_bmap), &a)); 1297 } 1298 1299 const int vop_strategy_vp_offsets[] = { 1300 VOPARG_OFFSETOF(struct vop_strategy_args,a_vp), 1301 VDESC_NO_OFFSET 1302 }; 1303 const struct vnodeop_desc vop_strategy_desc = { 1304 34, 1305 "vop_strategy", 1306 0, 1307 vop_strategy_vp_offsets, 1308 VDESC_NO_OFFSET, 1309 VDESC_NO_OFFSET, 1310 VDESC_NO_OFFSET, 1311 VDESC_NO_OFFSET, 1312 NULL, 1313 }; 1314 int 1315 VOP_STRATEGY(struct vnode *vp, 1316 struct buf *bp) 1317 { 1318 struct vop_strategy_args a; 1319 #ifdef VNODE_LOCKDEBUG 1320 #endif 1321 a.a_desc = VDESC(vop_strategy); 1322 a.a_vp = vp; 1323 a.a_bp = bp; 1324 return (VCALL(vp, VOFFSET(vop_strategy), &a)); 1325 } 1326 1327 const int vop_print_vp_offsets[] = { 1328 VOPARG_OFFSETOF(struct vop_print_args,a_vp), 1329 VDESC_NO_OFFSET 1330 }; 1331 const struct vnodeop_desc vop_print_desc = { 1332 35, 1333 "vop_print", 1334 0, 1335 vop_print_vp_offsets, 1336 VDESC_NO_OFFSET, 1337 VDESC_NO_OFFSET, 1338 VDESC_NO_OFFSET, 1339 VDESC_NO_OFFSET, 1340 NULL, 1341 }; 1342 int 1343 VOP_PRINT(struct vnode *vp) 1344 { 1345 struct vop_print_args a; 1346 #ifdef VNODE_LOCKDEBUG 1347 #endif 1348 a.a_desc = VDESC(vop_print); 1349 a.a_vp = vp; 1350 return (VCALL(vp, VOFFSET(vop_print), &a)); 1351 } 1352 1353 const int vop_islocked_vp_offsets[] = { 1354 VOPARG_OFFSETOF(struct vop_islocked_args,a_vp), 1355 VDESC_NO_OFFSET 1356 }; 1357 const struct vnodeop_desc vop_islocked_desc = { 1358 36, 1359 "vop_islocked", 1360 0, 1361 vop_islocked_vp_offsets, 1362 VDESC_NO_OFFSET, 1363 VDESC_NO_OFFSET, 1364 VDESC_NO_OFFSET, 1365 VDESC_NO_OFFSET, 1366 NULL, 1367 }; 1368 int 1369 VOP_ISLOCKED(struct vnode *vp) 1370 { 1371 struct vop_islocked_args a; 1372 #ifdef VNODE_LOCKDEBUG 1373 #endif 1374 a.a_desc = VDESC(vop_islocked); 1375 a.a_vp = vp; 1376 return (VCALL(vp, VOFFSET(vop_islocked), &a)); 1377 } 1378 1379 const int vop_pathconf_vp_offsets[] = { 1380 VOPARG_OFFSETOF(struct vop_pathconf_args,a_vp), 1381 VDESC_NO_OFFSET 1382 }; 1383 const struct vnodeop_desc vop_pathconf_desc = { 1384 37, 1385 "vop_pathconf", 1386 0, 1387 vop_pathconf_vp_offsets, 1388 VDESC_NO_OFFSET, 1389 VDESC_NO_OFFSET, 1390 VDESC_NO_OFFSET, 1391 VDESC_NO_OFFSET, 1392 NULL, 1393 }; 1394 int 1395 VOP_PATHCONF(struct vnode *vp, 1396 int name, 1397 register_t *retval) 1398 { 1399 struct vop_pathconf_args a; 1400 #ifdef VNODE_LOCKDEBUG 1401 int islocked_vp; 1402 #endif 1403 a.a_desc = VDESC(vop_pathconf); 1404 a.a_vp = vp; 1405 #ifdef VNODE_LOCKDEBUG 1406 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1407 if (islocked_vp != 1) 1408 panic("vop_pathconf: vp: locked %d, expected %d", islocked_vp, 1); 1409 #endif 1410 a.a_name = name; 1411 a.a_retval = retval; 1412 return (VCALL(vp, VOFFSET(vop_pathconf), &a)); 1413 } 1414 1415 const int vop_advlock_vp_offsets[] = { 1416 VOPARG_OFFSETOF(struct vop_advlock_args,a_vp), 1417 VDESC_NO_OFFSET 1418 }; 1419 const struct vnodeop_desc vop_advlock_desc = { 1420 38, 1421 "vop_advlock", 1422 0, 1423 vop_advlock_vp_offsets, 1424 VDESC_NO_OFFSET, 1425 VDESC_NO_OFFSET, 1426 VDESC_NO_OFFSET, 1427 VDESC_NO_OFFSET, 1428 NULL, 1429 }; 1430 int 1431 VOP_ADVLOCK(struct vnode *vp, 1432 void *id, 1433 int op, 1434 struct flock *fl, 1435 int flags) 1436 { 1437 struct vop_advlock_args a; 1438 #ifdef VNODE_LOCKDEBUG 1439 int islocked_vp; 1440 #endif 1441 a.a_desc = VDESC(vop_advlock); 1442 a.a_vp = vp; 1443 #ifdef VNODE_LOCKDEBUG 1444 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0; 1445 if (islocked_vp != 0) 1446 panic("vop_advlock: vp: locked %d, expected %d", islocked_vp, 0); 1447 #endif 1448 a.a_id = id; 1449 a.a_op = op; 1450 a.a_fl = fl; 1451 a.a_flags = flags; 1452 return (VCALL(vp, VOFFSET(vop_advlock), &a)); 1453 } 1454 1455 const int vop_lease_vp_offsets[] = { 1456 VOPARG_OFFSETOF(struct vop_lease_args,a_vp), 1457 VDESC_NO_OFFSET 1458 }; 1459 const struct vnodeop_desc vop_lease_desc = { 1460 39, 1461 "vop_lease", 1462 0, 1463 vop_lease_vp_offsets, 1464 VDESC_NO_OFFSET, 1465 VOPARG_OFFSETOF(struct vop_lease_args, a_cred), 1466 VOPARG_OFFSETOF(struct vop_lease_args, a_l), 1467 VDESC_NO_OFFSET, 1468 NULL, 1469 }; 1470 int 1471 VOP_LEASE(struct vnode *vp, 1472 struct lwp *l, 1473 kauth_cred_t cred, 1474 int flag) 1475 { 1476 struct vop_lease_args a; 1477 #ifdef VNODE_LOCKDEBUG 1478 #endif 1479 a.a_desc = VDESC(vop_lease); 1480 a.a_vp = vp; 1481 a.a_l = l; 1482 a.a_cred = cred; 1483 a.a_flag = flag; 1484 return (VCALL(vp, VOFFSET(vop_lease), &a)); 1485 } 1486 1487 const int vop_whiteout_vp_offsets[] = { 1488 VOPARG_OFFSETOF(struct vop_whiteout_args,a_dvp), 1489 VDESC_NO_OFFSET 1490 }; 1491 const struct vnodeop_desc vop_whiteout_desc = { 1492 40, 1493 "vop_whiteout", 1494 0, 1495 vop_whiteout_vp_offsets, 1496 VDESC_NO_OFFSET, 1497 VDESC_NO_OFFSET, 1498 VDESC_NO_OFFSET, 1499 VOPARG_OFFSETOF(struct vop_whiteout_args, a_cnp), 1500 NULL, 1501 }; 1502 int 1503 VOP_WHITEOUT(struct vnode *dvp, 1504 struct componentname *cnp, 1505 int flags) 1506 { 1507 struct vop_whiteout_args a; 1508 #ifdef VNODE_LOCKDEBUG 1509 int islocked_dvp; 1510 #endif 1511 a.a_desc = VDESC(vop_whiteout); 1512 a.a_dvp = dvp; 1513 #ifdef VNODE_LOCKDEBUG 1514 islocked_dvp = (dvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1; 1515 if (islocked_dvp != 1) 1516 panic("vop_whiteout: dvp: locked %d, expected %d", islocked_dvp, 1); 1517 #endif 1518 a.a_cnp = cnp; 1519 a.a_flags = flags; 1520 return (VCALL(dvp, VOFFSET(vop_whiteout), &a)); 1521 } 1522 1523 const int vop_getpages_vp_offsets[] = { 1524 VOPARG_OFFSETOF(struct vop_getpages_args,a_vp), 1525 VDESC_NO_OFFSET 1526 }; 1527 const struct vnodeop_desc vop_getpages_desc = { 1528 41, 1529 "vop_getpages", 1530 0, 1531 vop_getpages_vp_offsets, 1532 VDESC_NO_OFFSET, 1533 VDESC_NO_OFFSET, 1534 VDESC_NO_OFFSET, 1535 VDESC_NO_OFFSET, 1536 NULL, 1537 }; 1538 int 1539 VOP_GETPAGES(struct vnode *vp, 1540 voff_t offset, 1541 struct vm_page **m, 1542 int *count, 1543 int centeridx, 1544 vm_prot_t access_type, 1545 int advice, 1546 int flags) 1547 { 1548 struct vop_getpages_args a; 1549 #ifdef VNODE_LOCKDEBUG 1550 #endif 1551 a.a_desc = VDESC(vop_getpages); 1552 a.a_vp = vp; 1553 a.a_offset = offset; 1554 a.a_m = m; 1555 a.a_count = count; 1556 a.a_centeridx = centeridx; 1557 a.a_access_type = access_type; 1558 a.a_advice = advice; 1559 a.a_flags = flags; 1560 return (VCALL(vp, VOFFSET(vop_getpages), &a)); 1561 } 1562 1563 const int vop_putpages_vp_offsets[] = { 1564 VOPARG_OFFSETOF(struct vop_putpages_args,a_vp), 1565 VDESC_NO_OFFSET 1566 }; 1567 const struct vnodeop_desc vop_putpages_desc = { 1568 42, 1569 "vop_putpages", 1570 0, 1571 vop_putpages_vp_offsets, 1572 VDESC_NO_OFFSET, 1573 VDESC_NO_OFFSET, 1574 VDESC_NO_OFFSET, 1575 VDESC_NO_OFFSET, 1576 NULL, 1577 }; 1578 int 1579 VOP_PUTPAGES(struct vnode *vp, 1580 voff_t offlo, 1581 voff_t offhi, 1582 int flags) 1583 { 1584 struct vop_putpages_args a; 1585 #ifdef VNODE_LOCKDEBUG 1586 #endif 1587 a.a_desc = VDESC(vop_putpages); 1588 a.a_vp = vp; 1589 a.a_offlo = offlo; 1590 a.a_offhi = offhi; 1591 a.a_flags = flags; 1592 return (VCALL(vp, VOFFSET(vop_putpages), &a)); 1593 } 1594 1595 const int vop_closeextattr_vp_offsets[] = { 1596 VOPARG_OFFSETOF(struct vop_closeextattr_args,a_vp), 1597 VDESC_NO_OFFSET 1598 }; 1599 const struct vnodeop_desc vop_closeextattr_desc = { 1600 43, 1601 "vop_closeextattr", 1602 0, 1603 vop_closeextattr_vp_offsets, 1604 VDESC_NO_OFFSET, 1605 VOPARG_OFFSETOF(struct vop_closeextattr_args, a_cred), 1606 VOPARG_OFFSETOF(struct vop_closeextattr_args, a_l), 1607 VDESC_NO_OFFSET, 1608 NULL, 1609 }; 1610 int 1611 VOP_CLOSEEXTATTR(struct vnode *vp, 1612 int commit, 1613 kauth_cred_t cred, 1614 struct lwp *l) 1615 { 1616 struct vop_closeextattr_args a; 1617 #ifdef VNODE_LOCKDEBUG 1618 int islocked_vp; 1619 #endif 1620 a.a_desc = VDESC(vop_closeextattr); 1621 a.a_vp = vp; 1622 #ifdef VNODE_LOCKDEBUG 1623 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1624 if (islocked_vp != 1) 1625 panic("vop_closeextattr: vp: locked %d, expected %d", islocked_vp, 1); 1626 #endif 1627 a.a_commit = commit; 1628 a.a_cred = cred; 1629 a.a_l = l; 1630 return (VCALL(vp, VOFFSET(vop_closeextattr), &a)); 1631 } 1632 1633 const int vop_getextattr_vp_offsets[] = { 1634 VOPARG_OFFSETOF(struct vop_getextattr_args,a_vp), 1635 VDESC_NO_OFFSET 1636 }; 1637 const struct vnodeop_desc vop_getextattr_desc = { 1638 44, 1639 "vop_getextattr", 1640 0, 1641 vop_getextattr_vp_offsets, 1642 VDESC_NO_OFFSET, 1643 VOPARG_OFFSETOF(struct vop_getextattr_args, a_cred), 1644 VOPARG_OFFSETOF(struct vop_getextattr_args, a_l), 1645 VDESC_NO_OFFSET, 1646 NULL, 1647 }; 1648 int 1649 VOP_GETEXTATTR(struct vnode *vp, 1650 int attrnamespace, 1651 const char *name, 1652 struct uio *uio, 1653 size_t *size, 1654 kauth_cred_t cred, 1655 struct lwp *l) 1656 { 1657 struct vop_getextattr_args a; 1658 #ifdef VNODE_LOCKDEBUG 1659 int islocked_vp; 1660 #endif 1661 a.a_desc = VDESC(vop_getextattr); 1662 a.a_vp = vp; 1663 #ifdef VNODE_LOCKDEBUG 1664 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1665 if (islocked_vp != 1) 1666 panic("vop_getextattr: vp: locked %d, expected %d", islocked_vp, 1); 1667 #endif 1668 a.a_attrnamespace = attrnamespace; 1669 a.a_name = name; 1670 a.a_uio = uio; 1671 a.a_size = size; 1672 a.a_cred = cred; 1673 a.a_l = l; 1674 return (VCALL(vp, VOFFSET(vop_getextattr), &a)); 1675 } 1676 1677 const int vop_listextattr_vp_offsets[] = { 1678 VOPARG_OFFSETOF(struct vop_listextattr_args,a_vp), 1679 VDESC_NO_OFFSET 1680 }; 1681 const struct vnodeop_desc vop_listextattr_desc = { 1682 45, 1683 "vop_listextattr", 1684 0, 1685 vop_listextattr_vp_offsets, 1686 VDESC_NO_OFFSET, 1687 VOPARG_OFFSETOF(struct vop_listextattr_args, a_cred), 1688 VOPARG_OFFSETOF(struct vop_listextattr_args, a_l), 1689 VDESC_NO_OFFSET, 1690 NULL, 1691 }; 1692 int 1693 VOP_LISTEXTATTR(struct vnode *vp, 1694 int attrnamespace, 1695 struct uio *uio, 1696 size_t *size, 1697 kauth_cred_t cred, 1698 struct lwp *l) 1699 { 1700 struct vop_listextattr_args a; 1701 #ifdef VNODE_LOCKDEBUG 1702 int islocked_vp; 1703 #endif 1704 a.a_desc = VDESC(vop_listextattr); 1705 a.a_vp = vp; 1706 #ifdef VNODE_LOCKDEBUG 1707 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1708 if (islocked_vp != 1) 1709 panic("vop_listextattr: vp: locked %d, expected %d", islocked_vp, 1); 1710 #endif 1711 a.a_attrnamespace = attrnamespace; 1712 a.a_uio = uio; 1713 a.a_size = size; 1714 a.a_cred = cred; 1715 a.a_l = l; 1716 return (VCALL(vp, VOFFSET(vop_listextattr), &a)); 1717 } 1718 1719 const int vop_openextattr_vp_offsets[] = { 1720 VOPARG_OFFSETOF(struct vop_openextattr_args,a_vp), 1721 VDESC_NO_OFFSET 1722 }; 1723 const struct vnodeop_desc vop_openextattr_desc = { 1724 46, 1725 "vop_openextattr", 1726 0, 1727 vop_openextattr_vp_offsets, 1728 VDESC_NO_OFFSET, 1729 VOPARG_OFFSETOF(struct vop_openextattr_args, a_cred), 1730 VOPARG_OFFSETOF(struct vop_openextattr_args, a_l), 1731 VDESC_NO_OFFSET, 1732 NULL, 1733 }; 1734 int 1735 VOP_OPENEXTATTR(struct vnode *vp, 1736 kauth_cred_t cred, 1737 struct lwp *l) 1738 { 1739 struct vop_openextattr_args a; 1740 #ifdef VNODE_LOCKDEBUG 1741 int islocked_vp; 1742 #endif 1743 a.a_desc = VDESC(vop_openextattr); 1744 a.a_vp = vp; 1745 #ifdef VNODE_LOCKDEBUG 1746 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1747 if (islocked_vp != 1) 1748 panic("vop_openextattr: vp: locked %d, expected %d", islocked_vp, 1); 1749 #endif 1750 a.a_cred = cred; 1751 a.a_l = l; 1752 return (VCALL(vp, VOFFSET(vop_openextattr), &a)); 1753 } 1754 1755 const int vop_deleteextattr_vp_offsets[] = { 1756 VOPARG_OFFSETOF(struct vop_deleteextattr_args,a_vp), 1757 VDESC_NO_OFFSET 1758 }; 1759 const struct vnodeop_desc vop_deleteextattr_desc = { 1760 47, 1761 "vop_deleteextattr", 1762 0, 1763 vop_deleteextattr_vp_offsets, 1764 VDESC_NO_OFFSET, 1765 VOPARG_OFFSETOF(struct vop_deleteextattr_args, a_cred), 1766 VOPARG_OFFSETOF(struct vop_deleteextattr_args, a_l), 1767 VDESC_NO_OFFSET, 1768 NULL, 1769 }; 1770 int 1771 VOP_DELETEEXTATTR(struct vnode *vp, 1772 int attrnamespace, 1773 const char *name, 1774 kauth_cred_t cred, 1775 struct lwp *l) 1776 { 1777 struct vop_deleteextattr_args a; 1778 #ifdef VNODE_LOCKDEBUG 1779 int islocked_vp; 1780 #endif 1781 a.a_desc = VDESC(vop_deleteextattr); 1782 a.a_vp = vp; 1783 #ifdef VNODE_LOCKDEBUG 1784 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1785 if (islocked_vp != 1) 1786 panic("vop_deleteextattr: vp: locked %d, expected %d", islocked_vp, 1); 1787 #endif 1788 a.a_attrnamespace = attrnamespace; 1789 a.a_name = name; 1790 a.a_cred = cred; 1791 a.a_l = l; 1792 return (VCALL(vp, VOFFSET(vop_deleteextattr), &a)); 1793 } 1794 1795 const int vop_setextattr_vp_offsets[] = { 1796 VOPARG_OFFSETOF(struct vop_setextattr_args,a_vp), 1797 VDESC_NO_OFFSET 1798 }; 1799 const struct vnodeop_desc vop_setextattr_desc = { 1800 48, 1801 "vop_setextattr", 1802 0, 1803 vop_setextattr_vp_offsets, 1804 VDESC_NO_OFFSET, 1805 VOPARG_OFFSETOF(struct vop_setextattr_args, a_cred), 1806 VOPARG_OFFSETOF(struct vop_setextattr_args, a_l), 1807 VDESC_NO_OFFSET, 1808 NULL, 1809 }; 1810 int 1811 VOP_SETEXTATTR(struct vnode *vp, 1812 int attrnamespace, 1813 const char *name, 1814 struct uio *uio, 1815 kauth_cred_t cred, 1816 struct lwp *l) 1817 { 1818 struct vop_setextattr_args a; 1819 #ifdef VNODE_LOCKDEBUG 1820 int islocked_vp; 1821 #endif 1822 a.a_desc = VDESC(vop_setextattr); 1823 a.a_vp = vp; 1824 #ifdef VNODE_LOCKDEBUG 1825 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1826 if (islocked_vp != 1) 1827 panic("vop_setextattr: vp: locked %d, expected %d", islocked_vp, 1); 1828 #endif 1829 a.a_attrnamespace = attrnamespace; 1830 a.a_name = name; 1831 a.a_uio = uio; 1832 a.a_cred = cred; 1833 a.a_l = l; 1834 return (VCALL(vp, VOFFSET(vop_setextattr), &a)); 1835 } 1836 1837 /* End of special cases. */ 1838 1839 const struct vnodeop_desc * const vfs_op_descs[] = { 1840 &vop_default_desc, /* MUST BE FIRST */ 1841 &vop_bwrite_desc, /* XXX: SPECIAL CASE */ 1842 1843 &vop_lookup_desc, 1844 &vop_create_desc, 1845 &vop_mknod_desc, 1846 &vop_open_desc, 1847 &vop_close_desc, 1848 &vop_access_desc, 1849 &vop_getattr_desc, 1850 &vop_setattr_desc, 1851 &vop_read_desc, 1852 &vop_write_desc, 1853 &vop_ioctl_desc, 1854 &vop_fcntl_desc, 1855 &vop_poll_desc, 1856 &vop_kqfilter_desc, 1857 &vop_revoke_desc, 1858 &vop_mmap_desc, 1859 &vop_fsync_desc, 1860 &vop_seek_desc, 1861 &vop_remove_desc, 1862 &vop_link_desc, 1863 &vop_rename_desc, 1864 &vop_mkdir_desc, 1865 &vop_rmdir_desc, 1866 &vop_symlink_desc, 1867 &vop_readdir_desc, 1868 &vop_readlink_desc, 1869 &vop_abortop_desc, 1870 &vop_inactive_desc, 1871 &vop_reclaim_desc, 1872 &vop_lock_desc, 1873 &vop_unlock_desc, 1874 &vop_bmap_desc, 1875 &vop_strategy_desc, 1876 &vop_print_desc, 1877 &vop_islocked_desc, 1878 &vop_pathconf_desc, 1879 &vop_advlock_desc, 1880 &vop_lease_desc, 1881 &vop_whiteout_desc, 1882 &vop_getpages_desc, 1883 &vop_putpages_desc, 1884 &vop_closeextattr_desc, 1885 &vop_getextattr_desc, 1886 &vop_listextattr_desc, 1887 &vop_openextattr_desc, 1888 &vop_deleteextattr_desc, 1889 &vop_setextattr_desc, 1890 NULL 1891 }; 1892 1893
Indexes created Tue Sep 23 22:09:46 GMT 2025