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