vnode_if.c revision 1.58
1 /* $NetBSD: vnode_if.c,v 1.58 2005/11/29 23:02:22 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 2005/11/02 12:38:59 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.58 2005/11/29 23:02:22 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, ioflag, cred) 439 struct vnode *vp; 440 struct uio *uio; 441 int ioflag; 442 struct ucred *cred; 443 { 444 struct vop_read_args a; 445 #ifdef VNODE_LOCKDEBUG 446 int islocked_vp; 447 #endif 448 a.a_desc = VDESC(vop_read); 449 a.a_vp = vp; 450 #ifdef VNODE_LOCKDEBUG 451 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 452 if (islocked_vp != 1) 453 panic("vop_read: vp: locked %d, expected %d", islocked_vp, 1); 454 #endif 455 a.a_uio = uio; 456 a.a_ioflag = ioflag; 457 a.a_cred = cred; 458 return (VCALL(vp, VOFFSET(vop_read), &a)); 459 } 460 #endif 461 462 const int vop_write_vp_offsets[] = { 463 VOPARG_OFFSETOF(struct vop_write_args,a_vp), 464 VDESC_NO_OFFSET 465 }; 466 const struct vnodeop_desc vop_write_desc = { 467 11, 468 "vop_write", 469 0, 470 vop_write_vp_offsets, 471 VDESC_NO_OFFSET, 472 VOPARG_OFFSETOF(struct vop_write_args, a_cred), 473 VDESC_NO_OFFSET, 474 VDESC_NO_OFFSET, 475 NULL, 476 }; 477 #ifdef VNODE_OP_NOINLINE 478 int 479 VOP_WRITE(vp, uio, ioflag, cred) 480 struct vnode *vp; 481 struct uio *uio; 482 int ioflag; 483 struct ucred *cred; 484 { 485 struct vop_write_args a; 486 #ifdef VNODE_LOCKDEBUG 487 int islocked_vp; 488 #endif 489 a.a_desc = VDESC(vop_write); 490 a.a_vp = vp; 491 #ifdef VNODE_LOCKDEBUG 492 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 493 if (islocked_vp != 1) 494 panic("vop_write: vp: locked %d, expected %d", islocked_vp, 1); 495 #endif 496 a.a_uio = uio; 497 a.a_ioflag = ioflag; 498 a.a_cred = cred; 499 return (VCALL(vp, VOFFSET(vop_write), &a)); 500 } 501 #endif 502 503 const int vop_ioctl_vp_offsets[] = { 504 VOPARG_OFFSETOF(struct vop_ioctl_args,a_vp), 505 VDESC_NO_OFFSET 506 }; 507 const struct vnodeop_desc vop_ioctl_desc = { 508 12, 509 "vop_ioctl", 510 0, 511 vop_ioctl_vp_offsets, 512 VDESC_NO_OFFSET, 513 VOPARG_OFFSETOF(struct vop_ioctl_args, a_cred), 514 VOPARG_OFFSETOF(struct vop_ioctl_args, a_p), 515 VDESC_NO_OFFSET, 516 NULL, 517 }; 518 #ifdef VNODE_OP_NOINLINE 519 int 520 VOP_IOCTL(vp, command, data, fflag, cred, p) 521 struct vnode *vp; 522 u_long command; 523 void *data; 524 int fflag; 525 struct ucred *cred; 526 struct proc *p; 527 { 528 struct vop_ioctl_args a; 529 #ifdef VNODE_LOCKDEBUG 530 int islocked_vp; 531 #endif 532 a.a_desc = VDESC(vop_ioctl); 533 a.a_vp = vp; 534 #ifdef VNODE_LOCKDEBUG 535 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0; 536 if (islocked_vp != 0) 537 panic("vop_ioctl: vp: locked %d, expected %d", islocked_vp, 0); 538 #endif 539 a.a_command = command; 540 a.a_data = data; 541 a.a_fflag = fflag; 542 a.a_cred = cred; 543 a.a_p = p; 544 return (VCALL(vp, VOFFSET(vop_ioctl), &a)); 545 } 546 #endif 547 548 const int vop_fcntl_vp_offsets[] = { 549 VOPARG_OFFSETOF(struct vop_fcntl_args,a_vp), 550 VDESC_NO_OFFSET 551 }; 552 const struct vnodeop_desc vop_fcntl_desc = { 553 13, 554 "vop_fcntl", 555 0, 556 vop_fcntl_vp_offsets, 557 VDESC_NO_OFFSET, 558 VOPARG_OFFSETOF(struct vop_fcntl_args, a_cred), 559 VOPARG_OFFSETOF(struct vop_fcntl_args, a_p), 560 VDESC_NO_OFFSET, 561 NULL, 562 }; 563 #ifdef VNODE_OP_NOINLINE 564 int 565 VOP_FCNTL(vp, command, data, fflag, cred, p) 566 struct vnode *vp; 567 u_int command; 568 void *data; 569 int fflag; 570 struct ucred *cred; 571 struct proc *p; 572 { 573 struct vop_fcntl_args a; 574 #ifdef VNODE_LOCKDEBUG 575 int islocked_vp; 576 #endif 577 a.a_desc = VDESC(vop_fcntl); 578 a.a_vp = vp; 579 #ifdef VNODE_LOCKDEBUG 580 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 581 if (islocked_vp != 1) 582 panic("vop_fcntl: vp: locked %d, expected %d", islocked_vp, 1); 583 #endif 584 a.a_command = command; 585 a.a_data = data; 586 a.a_fflag = fflag; 587 a.a_cred = cred; 588 a.a_p = p; 589 return (VCALL(vp, VOFFSET(vop_fcntl), &a)); 590 } 591 #endif 592 593 const int vop_poll_vp_offsets[] = { 594 VOPARG_OFFSETOF(struct vop_poll_args,a_vp), 595 VDESC_NO_OFFSET 596 }; 597 const struct vnodeop_desc vop_poll_desc = { 598 14, 599 "vop_poll", 600 0, 601 vop_poll_vp_offsets, 602 VDESC_NO_OFFSET, 603 VDESC_NO_OFFSET, 604 VOPARG_OFFSETOF(struct vop_poll_args, a_p), 605 VDESC_NO_OFFSET, 606 NULL, 607 }; 608 #ifdef VNODE_OP_NOINLINE 609 int 610 VOP_POLL(vp, events, p) 611 struct vnode *vp; 612 int events; 613 struct proc *p; 614 { 615 struct vop_poll_args a; 616 #ifdef VNODE_LOCKDEBUG 617 int islocked_vp; 618 #endif 619 a.a_desc = VDESC(vop_poll); 620 a.a_vp = vp; 621 #ifdef VNODE_LOCKDEBUG 622 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0; 623 if (islocked_vp != 0) 624 panic("vop_poll: vp: locked %d, expected %d", islocked_vp, 0); 625 #endif 626 a.a_events = events; 627 a.a_p = p; 628 return (VCALL(vp, VOFFSET(vop_poll), &a)); 629 } 630 #endif 631 632 const int vop_kqfilter_vp_offsets[] = { 633 VOPARG_OFFSETOF(struct vop_kqfilter_args,a_vp), 634 VDESC_NO_OFFSET 635 }; 636 const struct vnodeop_desc vop_kqfilter_desc = { 637 15, 638 "vop_kqfilter", 639 0, 640 vop_kqfilter_vp_offsets, 641 VDESC_NO_OFFSET, 642 VDESC_NO_OFFSET, 643 VDESC_NO_OFFSET, 644 VDESC_NO_OFFSET, 645 NULL, 646 }; 647 #ifdef VNODE_OP_NOINLINE 648 int 649 VOP_KQFILTER(vp, kn) 650 struct vnode *vp; 651 struct knote *kn; 652 { 653 struct vop_kqfilter_args a; 654 #ifdef VNODE_LOCKDEBUG 655 int islocked_vp; 656 #endif 657 a.a_desc = VDESC(vop_kqfilter); 658 a.a_vp = vp; 659 #ifdef VNODE_LOCKDEBUG 660 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0; 661 if (islocked_vp != 0) 662 panic("vop_kqfilter: vp: locked %d, expected %d", islocked_vp, 0); 663 #endif 664 a.a_kn = kn; 665 return (VCALL(vp, VOFFSET(vop_kqfilter), &a)); 666 } 667 #endif 668 669 const int vop_revoke_vp_offsets[] = { 670 VOPARG_OFFSETOF(struct vop_revoke_args,a_vp), 671 VDESC_NO_OFFSET 672 }; 673 const struct vnodeop_desc vop_revoke_desc = { 674 16, 675 "vop_revoke", 676 0, 677 vop_revoke_vp_offsets, 678 VDESC_NO_OFFSET, 679 VDESC_NO_OFFSET, 680 VDESC_NO_OFFSET, 681 VDESC_NO_OFFSET, 682 NULL, 683 }; 684 #ifdef VNODE_OP_NOINLINE 685 int 686 VOP_REVOKE(vp, flags) 687 struct vnode *vp; 688 int flags; 689 { 690 struct vop_revoke_args a; 691 #ifdef VNODE_LOCKDEBUG 692 int islocked_vp; 693 #endif 694 a.a_desc = VDESC(vop_revoke); 695 a.a_vp = vp; 696 #ifdef VNODE_LOCKDEBUG 697 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0; 698 if (islocked_vp != 0) 699 panic("vop_revoke: vp: locked %d, expected %d", islocked_vp, 0); 700 #endif 701 a.a_flags = flags; 702 return (VCALL(vp, VOFFSET(vop_revoke), &a)); 703 } 704 #endif 705 706 const int vop_mmap_vp_offsets[] = { 707 VOPARG_OFFSETOF(struct vop_mmap_args,a_vp), 708 VDESC_NO_OFFSET 709 }; 710 const struct vnodeop_desc vop_mmap_desc = { 711 17, 712 "vop_mmap", 713 0, 714 vop_mmap_vp_offsets, 715 VDESC_NO_OFFSET, 716 VOPARG_OFFSETOF(struct vop_mmap_args, a_cred), 717 VOPARG_OFFSETOF(struct vop_mmap_args, a_p), 718 VDESC_NO_OFFSET, 719 NULL, 720 }; 721 #ifdef VNODE_OP_NOINLINE 722 int 723 VOP_MMAP(vp, fflags, cred, p) 724 struct vnode *vp; 725 int fflags; 726 struct ucred *cred; 727 struct proc *p; 728 { 729 struct vop_mmap_args a; 730 #ifdef VNODE_LOCKDEBUG 731 #endif 732 a.a_desc = VDESC(vop_mmap); 733 a.a_vp = vp; 734 a.a_fflags = fflags; 735 a.a_cred = cred; 736 a.a_p = p; 737 return (VCALL(vp, VOFFSET(vop_mmap), &a)); 738 } 739 #endif 740 741 const int vop_fsync_vp_offsets[] = { 742 VOPARG_OFFSETOF(struct vop_fsync_args,a_vp), 743 VDESC_NO_OFFSET 744 }; 745 const struct vnodeop_desc vop_fsync_desc = { 746 18, 747 "vop_fsync", 748 0, 749 vop_fsync_vp_offsets, 750 VDESC_NO_OFFSET, 751 VOPARG_OFFSETOF(struct vop_fsync_args, a_cred), 752 VOPARG_OFFSETOF(struct vop_fsync_args, a_p), 753 VDESC_NO_OFFSET, 754 NULL, 755 }; 756 #ifdef VNODE_OP_NOINLINE 757 int 758 VOP_FSYNC(vp, cred, flags, offlo, offhi, p) 759 struct vnode *vp; 760 struct ucred *cred; 761 int flags; 762 off_t offlo; 763 off_t offhi; 764 struct proc *p; 765 { 766 struct vop_fsync_args a; 767 #ifdef VNODE_LOCKDEBUG 768 int islocked_vp; 769 #endif 770 a.a_desc = VDESC(vop_fsync); 771 a.a_vp = vp; 772 #ifdef VNODE_LOCKDEBUG 773 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 774 if (islocked_vp != 1) 775 panic("vop_fsync: vp: locked %d, expected %d", islocked_vp, 1); 776 #endif 777 a.a_cred = cred; 778 a.a_flags = flags; 779 a.a_offlo = offlo; 780 a.a_offhi = offhi; 781 a.a_p = p; 782 return (VCALL(vp, VOFFSET(vop_fsync), &a)); 783 } 784 #endif 785 786 const int vop_seek_vp_offsets[] = { 787 VOPARG_OFFSETOF(struct vop_seek_args,a_vp), 788 VDESC_NO_OFFSET 789 }; 790 const struct vnodeop_desc vop_seek_desc = { 791 19, 792 "vop_seek", 793 0, 794 vop_seek_vp_offsets, 795 VDESC_NO_OFFSET, 796 VOPARG_OFFSETOF(struct vop_seek_args, a_cred), 797 VDESC_NO_OFFSET, 798 VDESC_NO_OFFSET, 799 NULL, 800 }; 801 #ifdef VNODE_OP_NOINLINE 802 int 803 VOP_SEEK(vp, oldoff, newoff, cred) 804 struct vnode *vp; 805 off_t oldoff; 806 off_t newoff; 807 struct ucred *cred; 808 { 809 struct vop_seek_args a; 810 #ifdef VNODE_LOCKDEBUG 811 #endif 812 a.a_desc = VDESC(vop_seek); 813 a.a_vp = vp; 814 a.a_oldoff = oldoff; 815 a.a_newoff = newoff; 816 a.a_cred = cred; 817 return (VCALL(vp, VOFFSET(vop_seek), &a)); 818 } 819 #endif 820 821 const int vop_remove_vp_offsets[] = { 822 VOPARG_OFFSETOF(struct vop_remove_args,a_dvp), 823 VOPARG_OFFSETOF(struct vop_remove_args,a_vp), 824 VDESC_NO_OFFSET 825 }; 826 const struct vnodeop_desc vop_remove_desc = { 827 20, 828 "vop_remove", 829 0 | VDESC_VP0_WILLPUT | VDESC_VP1_WILLPUT, 830 vop_remove_vp_offsets, 831 VDESC_NO_OFFSET, 832 VDESC_NO_OFFSET, 833 VDESC_NO_OFFSET, 834 VOPARG_OFFSETOF(struct vop_remove_args, a_cnp), 835 NULL, 836 }; 837 #ifdef VNODE_OP_NOINLINE 838 int 839 VOP_REMOVE(dvp, vp, cnp) 840 struct vnode *dvp; 841 struct vnode *vp; 842 struct componentname *cnp; 843 { 844 struct vop_remove_args a; 845 #ifdef VNODE_LOCKDEBUG 846 int islocked_dvp; 847 int islocked_vp; 848 #endif 849 a.a_desc = VDESC(vop_remove); 850 a.a_dvp = dvp; 851 #ifdef VNODE_LOCKDEBUG 852 islocked_dvp = (dvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1; 853 if (islocked_dvp != 1) 854 panic("vop_remove: dvp: locked %d, expected %d", islocked_dvp, 1); 855 #endif 856 a.a_vp = vp; 857 #ifdef VNODE_LOCKDEBUG 858 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 859 if (islocked_vp != 1) 860 panic("vop_remove: vp: locked %d, expected %d", islocked_vp, 1); 861 #endif 862 a.a_cnp = cnp; 863 return (VCALL(dvp, VOFFSET(vop_remove), &a)); 864 } 865 #endif 866 867 const int vop_link_vp_offsets[] = { 868 VOPARG_OFFSETOF(struct vop_link_args,a_dvp), 869 VOPARG_OFFSETOF(struct vop_link_args,a_vp), 870 VDESC_NO_OFFSET 871 }; 872 const struct vnodeop_desc vop_link_desc = { 873 21, 874 "vop_link", 875 0 | VDESC_VP0_WILLPUT, 876 vop_link_vp_offsets, 877 VDESC_NO_OFFSET, 878 VDESC_NO_OFFSET, 879 VDESC_NO_OFFSET, 880 VOPARG_OFFSETOF(struct vop_link_args, a_cnp), 881 NULL, 882 }; 883 #ifdef VNODE_OP_NOINLINE 884 int 885 VOP_LINK(dvp, vp, cnp) 886 struct vnode *dvp; 887 struct vnode *vp; 888 struct componentname *cnp; 889 { 890 struct vop_link_args a; 891 #ifdef VNODE_LOCKDEBUG 892 int islocked_dvp; 893 int islocked_vp; 894 #endif 895 a.a_desc = VDESC(vop_link); 896 a.a_dvp = dvp; 897 #ifdef VNODE_LOCKDEBUG 898 islocked_dvp = (dvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1; 899 if (islocked_dvp != 1) 900 panic("vop_link: dvp: locked %d, expected %d", islocked_dvp, 1); 901 #endif 902 a.a_vp = vp; 903 #ifdef VNODE_LOCKDEBUG 904 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0; 905 if (islocked_vp != 0) 906 panic("vop_link: vp: locked %d, expected %d", islocked_vp, 0); 907 #endif 908 a.a_cnp = cnp; 909 return (VCALL(dvp, VOFFSET(vop_link), &a)); 910 } 911 #endif 912 913 const int vop_rename_vp_offsets[] = { 914 VOPARG_OFFSETOF(struct vop_rename_args,a_fdvp), 915 VOPARG_OFFSETOF(struct vop_rename_args,a_fvp), 916 VOPARG_OFFSETOF(struct vop_rename_args,a_tdvp), 917 VOPARG_OFFSETOF(struct vop_rename_args,a_tvp), 918 VDESC_NO_OFFSET 919 }; 920 const struct vnodeop_desc vop_rename_desc = { 921 22, 922 "vop_rename", 923 0 | VDESC_VP0_WILLRELE | VDESC_VP1_WILLRELE | VDESC_VP2_WILLPUT | VDESC_VP3_WILLPUT, 924 vop_rename_vp_offsets, 925 VDESC_NO_OFFSET, 926 VDESC_NO_OFFSET, 927 VDESC_NO_OFFSET, 928 VOPARG_OFFSETOF(struct vop_rename_args, a_fcnp), 929 NULL, 930 }; 931 #ifdef VNODE_OP_NOINLINE 932 int 933 VOP_RENAME(fdvp, fvp, fcnp, tdvp, tvp, tcnp) 934 struct vnode *fdvp; 935 struct vnode *fvp; 936 struct componentname *fcnp; 937 struct vnode *tdvp; 938 struct vnode *tvp; 939 struct componentname *tcnp; 940 { 941 struct vop_rename_args a; 942 #ifdef VNODE_LOCKDEBUG 943 int islocked_fdvp; 944 int islocked_fvp; 945 int islocked_tdvp; 946 #endif 947 a.a_desc = VDESC(vop_rename); 948 a.a_fdvp = fdvp; 949 #ifdef VNODE_LOCKDEBUG 950 islocked_fdvp = (fdvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(fdvp) == LK_EXCLUSIVE) : 0; 951 if (islocked_fdvp != 0) 952 panic("vop_rename: fdvp: locked %d, expected %d", islocked_fdvp, 0); 953 #endif 954 a.a_fvp = fvp; 955 #ifdef VNODE_LOCKDEBUG 956 islocked_fvp = (fvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(fvp) == LK_EXCLUSIVE) : 0; 957 if (islocked_fvp != 0) 958 panic("vop_rename: fvp: locked %d, expected %d", islocked_fvp, 0); 959 #endif 960 a.a_fcnp = fcnp; 961 a.a_tdvp = tdvp; 962 #ifdef VNODE_LOCKDEBUG 963 islocked_tdvp = (tdvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(tdvp) == LK_EXCLUSIVE) : 1; 964 if (islocked_tdvp != 1) 965 panic("vop_rename: tdvp: locked %d, expected %d", islocked_tdvp, 1); 966 #endif 967 a.a_tvp = tvp; 968 a.a_tcnp = tcnp; 969 return (VCALL(fdvp, VOFFSET(vop_rename), &a)); 970 } 971 #endif 972 973 const int vop_mkdir_vp_offsets[] = { 974 VOPARG_OFFSETOF(struct vop_mkdir_args,a_dvp), 975 VDESC_NO_OFFSET 976 }; 977 const struct vnodeop_desc vop_mkdir_desc = { 978 23, 979 "vop_mkdir", 980 0 | VDESC_VP0_WILLPUT, 981 vop_mkdir_vp_offsets, 982 VOPARG_OFFSETOF(struct vop_mkdir_args, a_vpp), 983 VDESC_NO_OFFSET, 984 VDESC_NO_OFFSET, 985 VOPARG_OFFSETOF(struct vop_mkdir_args, a_cnp), 986 NULL, 987 }; 988 #ifdef VNODE_OP_NOINLINE 989 int 990 VOP_MKDIR(dvp, vpp, cnp, vap) 991 struct vnode *dvp; 992 struct vnode **vpp; 993 struct componentname *cnp; 994 struct vattr *vap; 995 { 996 struct vop_mkdir_args a; 997 #ifdef VNODE_LOCKDEBUG 998 int islocked_dvp; 999 #endif 1000 a.a_desc = VDESC(vop_mkdir); 1001 a.a_dvp = dvp; 1002 #ifdef VNODE_LOCKDEBUG 1003 islocked_dvp = (dvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1; 1004 if (islocked_dvp != 1) 1005 panic("vop_mkdir: dvp: locked %d, expected %d", islocked_dvp, 1); 1006 #endif 1007 a.a_vpp = vpp; 1008 a.a_cnp = cnp; 1009 a.a_vap = vap; 1010 return (VCALL(dvp, VOFFSET(vop_mkdir), &a)); 1011 } 1012 #endif 1013 1014 const int vop_rmdir_vp_offsets[] = { 1015 VOPARG_OFFSETOF(struct vop_rmdir_args,a_dvp), 1016 VOPARG_OFFSETOF(struct vop_rmdir_args,a_vp), 1017 VDESC_NO_OFFSET 1018 }; 1019 const struct vnodeop_desc vop_rmdir_desc = { 1020 24, 1021 "vop_rmdir", 1022 0 | VDESC_VP0_WILLPUT | VDESC_VP1_WILLPUT, 1023 vop_rmdir_vp_offsets, 1024 VDESC_NO_OFFSET, 1025 VDESC_NO_OFFSET, 1026 VDESC_NO_OFFSET, 1027 VOPARG_OFFSETOF(struct vop_rmdir_args, a_cnp), 1028 NULL, 1029 }; 1030 #ifdef VNODE_OP_NOINLINE 1031 int 1032 VOP_RMDIR(dvp, vp, cnp) 1033 struct vnode *dvp; 1034 struct vnode *vp; 1035 struct componentname *cnp; 1036 { 1037 struct vop_rmdir_args a; 1038 #ifdef VNODE_LOCKDEBUG 1039 int islocked_dvp; 1040 int islocked_vp; 1041 #endif 1042 a.a_desc = VDESC(vop_rmdir); 1043 a.a_dvp = dvp; 1044 #ifdef VNODE_LOCKDEBUG 1045 islocked_dvp = (dvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1; 1046 if (islocked_dvp != 1) 1047 panic("vop_rmdir: dvp: locked %d, expected %d", islocked_dvp, 1); 1048 #endif 1049 a.a_vp = vp; 1050 #ifdef VNODE_LOCKDEBUG 1051 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1052 if (islocked_vp != 1) 1053 panic("vop_rmdir: vp: locked %d, expected %d", islocked_vp, 1); 1054 #endif 1055 a.a_cnp = cnp; 1056 return (VCALL(dvp, VOFFSET(vop_rmdir), &a)); 1057 } 1058 #endif 1059 1060 const int vop_symlink_vp_offsets[] = { 1061 VOPARG_OFFSETOF(struct vop_symlink_args,a_dvp), 1062 VDESC_NO_OFFSET 1063 }; 1064 const struct vnodeop_desc vop_symlink_desc = { 1065 25, 1066 "vop_symlink", 1067 0 | VDESC_VP0_WILLPUT, 1068 vop_symlink_vp_offsets, 1069 VOPARG_OFFSETOF(struct vop_symlink_args, a_vpp), 1070 VDESC_NO_OFFSET, 1071 VDESC_NO_OFFSET, 1072 VOPARG_OFFSETOF(struct vop_symlink_args, a_cnp), 1073 NULL, 1074 }; 1075 #ifdef VNODE_OP_NOINLINE 1076 int 1077 VOP_SYMLINK(dvp, vpp, cnp, vap, target) 1078 struct vnode *dvp; 1079 struct vnode **vpp; 1080 struct componentname *cnp; 1081 struct vattr *vap; 1082 char *target; 1083 { 1084 struct vop_symlink_args a; 1085 #ifdef VNODE_LOCKDEBUG 1086 int islocked_dvp; 1087 #endif 1088 a.a_desc = VDESC(vop_symlink); 1089 a.a_dvp = dvp; 1090 #ifdef VNODE_LOCKDEBUG 1091 islocked_dvp = (dvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1; 1092 if (islocked_dvp != 1) 1093 panic("vop_symlink: dvp: locked %d, expected %d", islocked_dvp, 1); 1094 #endif 1095 a.a_vpp = vpp; 1096 a.a_cnp = cnp; 1097 a.a_vap = vap; 1098 a.a_target = target; 1099 return (VCALL(dvp, VOFFSET(vop_symlink), &a)); 1100 } 1101 #endif 1102 1103 const int vop_readdir_vp_offsets[] = { 1104 VOPARG_OFFSETOF(struct vop_readdir_args,a_vp), 1105 VDESC_NO_OFFSET 1106 }; 1107 const struct vnodeop_desc vop_readdir_desc = { 1108 26, 1109 "vop_readdir", 1110 0, 1111 vop_readdir_vp_offsets, 1112 VDESC_NO_OFFSET, 1113 VOPARG_OFFSETOF(struct vop_readdir_args, a_cred), 1114 VDESC_NO_OFFSET, 1115 VDESC_NO_OFFSET, 1116 NULL, 1117 }; 1118 #ifdef VNODE_OP_NOINLINE 1119 int 1120 VOP_READDIR(vp, uio, cred, eofflag, cookies, ncookies) 1121 struct vnode *vp; 1122 struct uio *uio; 1123 struct ucred *cred; 1124 int *eofflag; 1125 off_t **cookies; 1126 int *ncookies; 1127 { 1128 struct vop_readdir_args a; 1129 #ifdef VNODE_LOCKDEBUG 1130 int islocked_vp; 1131 #endif 1132 a.a_desc = VDESC(vop_readdir); 1133 a.a_vp = vp; 1134 #ifdef VNODE_LOCKDEBUG 1135 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1136 if (islocked_vp != 1) 1137 panic("vop_readdir: vp: locked %d, expected %d", islocked_vp, 1); 1138 #endif 1139 a.a_uio = uio; 1140 a.a_cred = cred; 1141 a.a_eofflag = eofflag; 1142 a.a_cookies = cookies; 1143 a.a_ncookies = ncookies; 1144 return (VCALL(vp, VOFFSET(vop_readdir), &a)); 1145 } 1146 #endif 1147 1148 const int vop_readlink_vp_offsets[] = { 1149 VOPARG_OFFSETOF(struct vop_readlink_args,a_vp), 1150 VDESC_NO_OFFSET 1151 }; 1152 const struct vnodeop_desc vop_readlink_desc = { 1153 27, 1154 "vop_readlink", 1155 0, 1156 vop_readlink_vp_offsets, 1157 VDESC_NO_OFFSET, 1158 VOPARG_OFFSETOF(struct vop_readlink_args, a_cred), 1159 VDESC_NO_OFFSET, 1160 VDESC_NO_OFFSET, 1161 NULL, 1162 }; 1163 #ifdef VNODE_OP_NOINLINE 1164 int 1165 VOP_READLINK(vp, uio, cred) 1166 struct vnode *vp; 1167 struct uio *uio; 1168 struct ucred *cred; 1169 { 1170 struct vop_readlink_args a; 1171 #ifdef VNODE_LOCKDEBUG 1172 int islocked_vp; 1173 #endif 1174 a.a_desc = VDESC(vop_readlink); 1175 a.a_vp = vp; 1176 #ifdef VNODE_LOCKDEBUG 1177 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1178 if (islocked_vp != 1) 1179 panic("vop_readlink: vp: locked %d, expected %d", islocked_vp, 1); 1180 #endif 1181 a.a_uio = uio; 1182 a.a_cred = cred; 1183 return (VCALL(vp, VOFFSET(vop_readlink), &a)); 1184 } 1185 #endif 1186 1187 const int vop_abortop_vp_offsets[] = { 1188 VOPARG_OFFSETOF(struct vop_abortop_args,a_dvp), 1189 VDESC_NO_OFFSET 1190 }; 1191 const struct vnodeop_desc vop_abortop_desc = { 1192 28, 1193 "vop_abortop", 1194 0, 1195 vop_abortop_vp_offsets, 1196 VDESC_NO_OFFSET, 1197 VDESC_NO_OFFSET, 1198 VDESC_NO_OFFSET, 1199 VOPARG_OFFSETOF(struct vop_abortop_args, a_cnp), 1200 NULL, 1201 }; 1202 #ifdef VNODE_OP_NOINLINE 1203 int 1204 VOP_ABORTOP(dvp, cnp) 1205 struct vnode *dvp; 1206 struct componentname *cnp; 1207 { 1208 struct vop_abortop_args a; 1209 #ifdef VNODE_LOCKDEBUG 1210 #endif 1211 a.a_desc = VDESC(vop_abortop); 1212 a.a_dvp = dvp; 1213 a.a_cnp = cnp; 1214 return (VCALL(dvp, VOFFSET(vop_abortop), &a)); 1215 } 1216 #endif 1217 1218 const int vop_inactive_vp_offsets[] = { 1219 VOPARG_OFFSETOF(struct vop_inactive_args,a_vp), 1220 VDESC_NO_OFFSET 1221 }; 1222 const struct vnodeop_desc vop_inactive_desc = { 1223 29, 1224 "vop_inactive", 1225 0 | VDESC_VP0_WILLUNLOCK, 1226 vop_inactive_vp_offsets, 1227 VDESC_NO_OFFSET, 1228 VDESC_NO_OFFSET, 1229 VOPARG_OFFSETOF(struct vop_inactive_args, a_p), 1230 VDESC_NO_OFFSET, 1231 NULL, 1232 }; 1233 #ifdef VNODE_OP_NOINLINE 1234 int 1235 VOP_INACTIVE(vp, p) 1236 struct vnode *vp; 1237 struct proc *p; 1238 { 1239 struct vop_inactive_args a; 1240 #ifdef VNODE_LOCKDEBUG 1241 int islocked_vp; 1242 #endif 1243 a.a_desc = VDESC(vop_inactive); 1244 a.a_vp = vp; 1245 #ifdef VNODE_LOCKDEBUG 1246 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1247 if (islocked_vp != 1) 1248 panic("vop_inactive: vp: locked %d, expected %d", islocked_vp, 1); 1249 #endif 1250 a.a_p = p; 1251 return (VCALL(vp, VOFFSET(vop_inactive), &a)); 1252 } 1253 #endif 1254 1255 const int vop_reclaim_vp_offsets[] = { 1256 VOPARG_OFFSETOF(struct vop_reclaim_args,a_vp), 1257 VDESC_NO_OFFSET 1258 }; 1259 const struct vnodeop_desc vop_reclaim_desc = { 1260 30, 1261 "vop_reclaim", 1262 0, 1263 vop_reclaim_vp_offsets, 1264 VDESC_NO_OFFSET, 1265 VDESC_NO_OFFSET, 1266 VOPARG_OFFSETOF(struct vop_reclaim_args, a_p), 1267 VDESC_NO_OFFSET, 1268 NULL, 1269 }; 1270 #ifdef VNODE_OP_NOINLINE 1271 int 1272 VOP_RECLAIM(vp, p) 1273 struct vnode *vp; 1274 struct proc *p; 1275 { 1276 struct vop_reclaim_args a; 1277 #ifdef VNODE_LOCKDEBUG 1278 int islocked_vp; 1279 #endif 1280 a.a_desc = VDESC(vop_reclaim); 1281 a.a_vp = vp; 1282 #ifdef VNODE_LOCKDEBUG 1283 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0; 1284 if (islocked_vp != 0) 1285 panic("vop_reclaim: vp: locked %d, expected %d", islocked_vp, 0); 1286 #endif 1287 a.a_p = p; 1288 return (VCALL(vp, VOFFSET(vop_reclaim), &a)); 1289 } 1290 #endif 1291 1292 const int vop_lock_vp_offsets[] = { 1293 VOPARG_OFFSETOF(struct vop_lock_args,a_vp), 1294 VDESC_NO_OFFSET 1295 }; 1296 const struct vnodeop_desc vop_lock_desc = { 1297 31, 1298 "vop_lock", 1299 0, 1300 vop_lock_vp_offsets, 1301 VDESC_NO_OFFSET, 1302 VDESC_NO_OFFSET, 1303 VDESC_NO_OFFSET, 1304 VDESC_NO_OFFSET, 1305 NULL, 1306 }; 1307 #ifdef VNODE_OP_NOINLINE 1308 int 1309 VOP_LOCK(vp, flags) 1310 struct vnode *vp; 1311 int flags; 1312 { 1313 struct vop_lock_args a; 1314 #ifdef VNODE_LOCKDEBUG 1315 int islocked_vp; 1316 #endif 1317 a.a_desc = VDESC(vop_lock); 1318 a.a_vp = vp; 1319 #ifdef VNODE_LOCKDEBUG 1320 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0; 1321 if (islocked_vp != 0) 1322 panic("vop_lock: vp: locked %d, expected %d", islocked_vp, 0); 1323 #endif 1324 a.a_flags = flags; 1325 return (VCALL(vp, VOFFSET(vop_lock), &a)); 1326 } 1327 #endif 1328 1329 const int vop_unlock_vp_offsets[] = { 1330 VOPARG_OFFSETOF(struct vop_unlock_args,a_vp), 1331 VDESC_NO_OFFSET 1332 }; 1333 const struct vnodeop_desc vop_unlock_desc = { 1334 32, 1335 "vop_unlock", 1336 0, 1337 vop_unlock_vp_offsets, 1338 VDESC_NO_OFFSET, 1339 VDESC_NO_OFFSET, 1340 VDESC_NO_OFFSET, 1341 VDESC_NO_OFFSET, 1342 NULL, 1343 }; 1344 #ifdef VNODE_OP_NOINLINE 1345 int 1346 VOP_UNLOCK(vp, flags) 1347 struct vnode *vp; 1348 int flags; 1349 { 1350 struct vop_unlock_args a; 1351 #ifdef VNODE_LOCKDEBUG 1352 int islocked_vp; 1353 #endif 1354 a.a_desc = VDESC(vop_unlock); 1355 a.a_vp = vp; 1356 #ifdef VNODE_LOCKDEBUG 1357 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1358 if (islocked_vp != 1) 1359 panic("vop_unlock: vp: locked %d, expected %d", islocked_vp, 1); 1360 #endif 1361 a.a_flags = flags; 1362 return (VCALL(vp, VOFFSET(vop_unlock), &a)); 1363 } 1364 #endif 1365 1366 const int vop_bmap_vp_offsets[] = { 1367 VOPARG_OFFSETOF(struct vop_bmap_args,a_vp), 1368 VDESC_NO_OFFSET 1369 }; 1370 const struct vnodeop_desc vop_bmap_desc = { 1371 33, 1372 "vop_bmap", 1373 0, 1374 vop_bmap_vp_offsets, 1375 VOPARG_OFFSETOF(struct vop_bmap_args, a_vpp), 1376 VDESC_NO_OFFSET, 1377 VDESC_NO_OFFSET, 1378 VDESC_NO_OFFSET, 1379 NULL, 1380 }; 1381 #ifdef VNODE_OP_NOINLINE 1382 int 1383 VOP_BMAP(vp, bn, vpp, bnp, runp) 1384 struct vnode *vp; 1385 daddr_t bn; 1386 struct vnode **vpp; 1387 daddr_t *bnp; 1388 int *runp; 1389 { 1390 struct vop_bmap_args a; 1391 #ifdef VNODE_LOCKDEBUG 1392 int islocked_vp; 1393 #endif 1394 a.a_desc = VDESC(vop_bmap); 1395 a.a_vp = vp; 1396 #ifdef VNODE_LOCKDEBUG 1397 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1398 if (islocked_vp != 1) 1399 panic("vop_bmap: vp: locked %d, expected %d", islocked_vp, 1); 1400 #endif 1401 a.a_bn = bn; 1402 a.a_vpp = vpp; 1403 a.a_bnp = bnp; 1404 a.a_runp = runp; 1405 return (VCALL(vp, VOFFSET(vop_bmap), &a)); 1406 } 1407 #endif 1408 1409 const int vop_strategy_vp_offsets[] = { 1410 VOPARG_OFFSETOF(struct vop_strategy_args,a_vp), 1411 VDESC_NO_OFFSET 1412 }; 1413 const struct vnodeop_desc vop_strategy_desc = { 1414 34, 1415 "vop_strategy", 1416 0, 1417 vop_strategy_vp_offsets, 1418 VDESC_NO_OFFSET, 1419 VDESC_NO_OFFSET, 1420 VDESC_NO_OFFSET, 1421 VDESC_NO_OFFSET, 1422 NULL, 1423 }; 1424 #ifdef VNODE_OP_NOINLINE 1425 int 1426 VOP_STRATEGY(vp, bp) 1427 struct vnode *vp; 1428 struct buf *bp; 1429 { 1430 struct vop_strategy_args a; 1431 #ifdef VNODE_LOCKDEBUG 1432 #endif 1433 a.a_desc = VDESC(vop_strategy); 1434 a.a_vp = vp; 1435 a.a_bp = bp; 1436 return (VCALL(vp, VOFFSET(vop_strategy), &a)); 1437 } 1438 #endif 1439 1440 const int vop_print_vp_offsets[] = { 1441 VOPARG_OFFSETOF(struct vop_print_args,a_vp), 1442 VDESC_NO_OFFSET 1443 }; 1444 const struct vnodeop_desc vop_print_desc = { 1445 35, 1446 "vop_print", 1447 0, 1448 vop_print_vp_offsets, 1449 VDESC_NO_OFFSET, 1450 VDESC_NO_OFFSET, 1451 VDESC_NO_OFFSET, 1452 VDESC_NO_OFFSET, 1453 NULL, 1454 }; 1455 #ifdef VNODE_OP_NOINLINE 1456 int 1457 VOP_PRINT(vp) 1458 struct vnode *vp; 1459 { 1460 struct vop_print_args a; 1461 #ifdef VNODE_LOCKDEBUG 1462 #endif 1463 a.a_desc = VDESC(vop_print); 1464 a.a_vp = vp; 1465 return (VCALL(vp, VOFFSET(vop_print), &a)); 1466 } 1467 #endif 1468 1469 const int vop_islocked_vp_offsets[] = { 1470 VOPARG_OFFSETOF(struct vop_islocked_args,a_vp), 1471 VDESC_NO_OFFSET 1472 }; 1473 const struct vnodeop_desc vop_islocked_desc = { 1474 36, 1475 "vop_islocked", 1476 0, 1477 vop_islocked_vp_offsets, 1478 VDESC_NO_OFFSET, 1479 VDESC_NO_OFFSET, 1480 VDESC_NO_OFFSET, 1481 VDESC_NO_OFFSET, 1482 NULL, 1483 }; 1484 #ifdef VNODE_OP_NOINLINE 1485 int 1486 VOP_ISLOCKED(vp) 1487 struct vnode *vp; 1488 { 1489 struct vop_islocked_args a; 1490 #ifdef VNODE_LOCKDEBUG 1491 #endif 1492 a.a_desc = VDESC(vop_islocked); 1493 a.a_vp = vp; 1494 return (VCALL(vp, VOFFSET(vop_islocked), &a)); 1495 } 1496 #endif 1497 1498 const int vop_pathconf_vp_offsets[] = { 1499 VOPARG_OFFSETOF(struct vop_pathconf_args,a_vp), 1500 VDESC_NO_OFFSET 1501 }; 1502 const struct vnodeop_desc vop_pathconf_desc = { 1503 37, 1504 "vop_pathconf", 1505 0, 1506 vop_pathconf_vp_offsets, 1507 VDESC_NO_OFFSET, 1508 VDESC_NO_OFFSET, 1509 VDESC_NO_OFFSET, 1510 VDESC_NO_OFFSET, 1511 NULL, 1512 }; 1513 #ifdef VNODE_OP_NOINLINE 1514 int 1515 VOP_PATHCONF(vp, name, retval) 1516 struct vnode *vp; 1517 int name; 1518 register_t *retval; 1519 { 1520 struct vop_pathconf_args a; 1521 #ifdef VNODE_LOCKDEBUG 1522 int islocked_vp; 1523 #endif 1524 a.a_desc = VDESC(vop_pathconf); 1525 a.a_vp = vp; 1526 #ifdef VNODE_LOCKDEBUG 1527 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1528 if (islocked_vp != 1) 1529 panic("vop_pathconf: vp: locked %d, expected %d", islocked_vp, 1); 1530 #endif 1531 a.a_name = name; 1532 a.a_retval = retval; 1533 return (VCALL(vp, VOFFSET(vop_pathconf), &a)); 1534 } 1535 #endif 1536 1537 const int vop_advlock_vp_offsets[] = { 1538 VOPARG_OFFSETOF(struct vop_advlock_args,a_vp), 1539 VDESC_NO_OFFSET 1540 }; 1541 const struct vnodeop_desc vop_advlock_desc = { 1542 38, 1543 "vop_advlock", 1544 0, 1545 vop_advlock_vp_offsets, 1546 VDESC_NO_OFFSET, 1547 VDESC_NO_OFFSET, 1548 VDESC_NO_OFFSET, 1549 VDESC_NO_OFFSET, 1550 NULL, 1551 }; 1552 #ifdef VNODE_OP_NOINLINE 1553 int 1554 VOP_ADVLOCK(vp, id, op, fl, flags) 1555 struct vnode *vp; 1556 void *id; 1557 int op; 1558 struct flock *fl; 1559 int flags; 1560 { 1561 struct vop_advlock_args a; 1562 #ifdef VNODE_LOCKDEBUG 1563 int islocked_vp; 1564 #endif 1565 a.a_desc = VDESC(vop_advlock); 1566 a.a_vp = vp; 1567 #ifdef VNODE_LOCKDEBUG 1568 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0; 1569 if (islocked_vp != 0) 1570 panic("vop_advlock: vp: locked %d, expected %d", islocked_vp, 0); 1571 #endif 1572 a.a_id = id; 1573 a.a_op = op; 1574 a.a_fl = fl; 1575 a.a_flags = flags; 1576 return (VCALL(vp, VOFFSET(vop_advlock), &a)); 1577 } 1578 #endif 1579 1580 const int vop_lease_vp_offsets[] = { 1581 VOPARG_OFFSETOF(struct vop_lease_args,a_vp), 1582 VDESC_NO_OFFSET 1583 }; 1584 const struct vnodeop_desc vop_lease_desc = { 1585 39, 1586 "vop_lease", 1587 0, 1588 vop_lease_vp_offsets, 1589 VDESC_NO_OFFSET, 1590 VOPARG_OFFSETOF(struct vop_lease_args, a_cred), 1591 VOPARG_OFFSETOF(struct vop_lease_args, a_p), 1592 VDESC_NO_OFFSET, 1593 NULL, 1594 }; 1595 #ifdef VNODE_OP_NOINLINE 1596 int 1597 VOP_LEASE(vp, p, cred, flag) 1598 struct vnode *vp; 1599 struct proc *p; 1600 struct ucred *cred; 1601 int flag; 1602 { 1603 struct vop_lease_args a; 1604 #ifdef VNODE_LOCKDEBUG 1605 #endif 1606 a.a_desc = VDESC(vop_lease); 1607 a.a_vp = vp; 1608 a.a_p = p; 1609 a.a_cred = cred; 1610 a.a_flag = flag; 1611 return (VCALL(vp, VOFFSET(vop_lease), &a)); 1612 } 1613 #endif 1614 1615 const int vop_whiteout_vp_offsets[] = { 1616 VOPARG_OFFSETOF(struct vop_whiteout_args,a_dvp), 1617 VDESC_NO_OFFSET 1618 }; 1619 const struct vnodeop_desc vop_whiteout_desc = { 1620 40, 1621 "vop_whiteout", 1622 0, 1623 vop_whiteout_vp_offsets, 1624 VDESC_NO_OFFSET, 1625 VDESC_NO_OFFSET, 1626 VDESC_NO_OFFSET, 1627 VOPARG_OFFSETOF(struct vop_whiteout_args, a_cnp), 1628 NULL, 1629 }; 1630 #ifdef VNODE_OP_NOINLINE 1631 int 1632 VOP_WHITEOUT(dvp, cnp, flags) 1633 struct vnode *dvp; 1634 struct componentname *cnp; 1635 int flags; 1636 { 1637 struct vop_whiteout_args a; 1638 #ifdef VNODE_LOCKDEBUG 1639 int islocked_dvp; 1640 #endif 1641 a.a_desc = VDESC(vop_whiteout); 1642 a.a_dvp = dvp; 1643 #ifdef VNODE_LOCKDEBUG 1644 islocked_dvp = (dvp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1; 1645 if (islocked_dvp != 1) 1646 panic("vop_whiteout: dvp: locked %d, expected %d", islocked_dvp, 1); 1647 #endif 1648 a.a_cnp = cnp; 1649 a.a_flags = flags; 1650 return (VCALL(dvp, VOFFSET(vop_whiteout), &a)); 1651 } 1652 #endif 1653 1654 const int vop_getpages_vp_offsets[] = { 1655 VOPARG_OFFSETOF(struct vop_getpages_args,a_vp), 1656 VDESC_NO_OFFSET 1657 }; 1658 const struct vnodeop_desc vop_getpages_desc = { 1659 41, 1660 "vop_getpages", 1661 0, 1662 vop_getpages_vp_offsets, 1663 VDESC_NO_OFFSET, 1664 VDESC_NO_OFFSET, 1665 VDESC_NO_OFFSET, 1666 VDESC_NO_OFFSET, 1667 NULL, 1668 }; 1669 #ifdef VNODE_OP_NOINLINE 1670 int 1671 VOP_GETPAGES(vp, offset, m, count, centeridx, access_type, advice, flags) 1672 struct vnode *vp; 1673 voff_t offset; 1674 struct vm_page **m; 1675 int *count; 1676 int centeridx; 1677 vm_prot_t access_type; 1678 int advice; 1679 int flags; 1680 { 1681 struct vop_getpages_args a; 1682 #ifdef VNODE_LOCKDEBUG 1683 #endif 1684 a.a_desc = VDESC(vop_getpages); 1685 a.a_vp = vp; 1686 a.a_offset = offset; 1687 a.a_m = m; 1688 a.a_count = count; 1689 a.a_centeridx = centeridx; 1690 a.a_access_type = access_type; 1691 a.a_advice = advice; 1692 a.a_flags = flags; 1693 return (VCALL(vp, VOFFSET(vop_getpages), &a)); 1694 } 1695 #endif 1696 1697 const int vop_putpages_vp_offsets[] = { 1698 VOPARG_OFFSETOF(struct vop_putpages_args,a_vp), 1699 VDESC_NO_OFFSET 1700 }; 1701 const struct vnodeop_desc vop_putpages_desc = { 1702 42, 1703 "vop_putpages", 1704 0, 1705 vop_putpages_vp_offsets, 1706 VDESC_NO_OFFSET, 1707 VDESC_NO_OFFSET, 1708 VDESC_NO_OFFSET, 1709 VDESC_NO_OFFSET, 1710 NULL, 1711 }; 1712 #ifdef VNODE_OP_NOINLINE 1713 int 1714 VOP_PUTPAGES(vp, offlo, offhi, flags) 1715 struct vnode *vp; 1716 voff_t offlo; 1717 voff_t offhi; 1718 int flags; 1719 { 1720 struct vop_putpages_args a; 1721 #ifdef VNODE_LOCKDEBUG 1722 #endif 1723 a.a_desc = VDESC(vop_putpages); 1724 a.a_vp = vp; 1725 a.a_offlo = offlo; 1726 a.a_offhi = offhi; 1727 a.a_flags = flags; 1728 return (VCALL(vp, VOFFSET(vop_putpages), &a)); 1729 } 1730 #endif 1731 1732 const int vop_closeextattr_vp_offsets[] = { 1733 VOPARG_OFFSETOF(struct vop_closeextattr_args,a_vp), 1734 VDESC_NO_OFFSET 1735 }; 1736 const struct vnodeop_desc vop_closeextattr_desc = { 1737 43, 1738 "vop_closeextattr", 1739 0, 1740 vop_closeextattr_vp_offsets, 1741 VDESC_NO_OFFSET, 1742 VOPARG_OFFSETOF(struct vop_closeextattr_args, a_cred), 1743 VOPARG_OFFSETOF(struct vop_closeextattr_args, a_p), 1744 VDESC_NO_OFFSET, 1745 NULL, 1746 }; 1747 #ifdef VNODE_OP_NOINLINE 1748 int 1749 VOP_CLOSEEXTATTR(vp, commit, cred, p) 1750 struct vnode *vp; 1751 int commit; 1752 struct ucred *cred; 1753 struct proc *p; 1754 { 1755 struct vop_closeextattr_args a; 1756 #ifdef VNODE_LOCKDEBUG 1757 int islocked_vp; 1758 #endif 1759 a.a_desc = VDESC(vop_closeextattr); 1760 a.a_vp = vp; 1761 #ifdef VNODE_LOCKDEBUG 1762 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1763 if (islocked_vp != 1) 1764 panic("vop_closeextattr: vp: locked %d, expected %d", islocked_vp, 1); 1765 #endif 1766 a.a_commit = commit; 1767 a.a_cred = cred; 1768 a.a_p = p; 1769 return (VCALL(vp, VOFFSET(vop_closeextattr), &a)); 1770 } 1771 #endif 1772 1773 const int vop_getextattr_vp_offsets[] = { 1774 VOPARG_OFFSETOF(struct vop_getextattr_args,a_vp), 1775 VDESC_NO_OFFSET 1776 }; 1777 const struct vnodeop_desc vop_getextattr_desc = { 1778 44, 1779 "vop_getextattr", 1780 0, 1781 vop_getextattr_vp_offsets, 1782 VDESC_NO_OFFSET, 1783 VOPARG_OFFSETOF(struct vop_getextattr_args, a_cred), 1784 VOPARG_OFFSETOF(struct vop_getextattr_args, a_p), 1785 VDESC_NO_OFFSET, 1786 NULL, 1787 }; 1788 #ifdef VNODE_OP_NOINLINE 1789 int 1790 VOP_GETEXTATTR(vp, attrnamespace, name, uio, size, cred, p) 1791 struct vnode *vp; 1792 int attrnamespace; 1793 const char *name; 1794 struct uio *uio; 1795 size_t *size; 1796 struct ucred *cred; 1797 struct proc *p; 1798 { 1799 struct vop_getextattr_args a; 1800 #ifdef VNODE_LOCKDEBUG 1801 int islocked_vp; 1802 #endif 1803 a.a_desc = VDESC(vop_getextattr); 1804 a.a_vp = vp; 1805 #ifdef VNODE_LOCKDEBUG 1806 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1807 if (islocked_vp != 1) 1808 panic("vop_getextattr: vp: locked %d, expected %d", islocked_vp, 1); 1809 #endif 1810 a.a_attrnamespace = attrnamespace; 1811 a.a_name = name; 1812 a.a_uio = uio; 1813 a.a_size = size; 1814 a.a_cred = cred; 1815 a.a_p = p; 1816 return (VCALL(vp, VOFFSET(vop_getextattr), &a)); 1817 } 1818 #endif 1819 1820 const int vop_listextattr_vp_offsets[] = { 1821 VOPARG_OFFSETOF(struct vop_listextattr_args,a_vp), 1822 VDESC_NO_OFFSET 1823 }; 1824 const struct vnodeop_desc vop_listextattr_desc = { 1825 45, 1826 "vop_listextattr", 1827 0, 1828 vop_listextattr_vp_offsets, 1829 VDESC_NO_OFFSET, 1830 VOPARG_OFFSETOF(struct vop_listextattr_args, a_cred), 1831 VOPARG_OFFSETOF(struct vop_listextattr_args, a_p), 1832 VDESC_NO_OFFSET, 1833 NULL, 1834 }; 1835 #ifdef VNODE_OP_NOINLINE 1836 int 1837 VOP_LISTEXTATTR(vp, attrnamespace, uio, size, cred, p) 1838 struct vnode *vp; 1839 int attrnamespace; 1840 struct uio *uio; 1841 size_t *size; 1842 struct ucred *cred; 1843 struct proc *p; 1844 { 1845 struct vop_listextattr_args a; 1846 #ifdef VNODE_LOCKDEBUG 1847 int islocked_vp; 1848 #endif 1849 a.a_desc = VDESC(vop_listextattr); 1850 a.a_vp = vp; 1851 #ifdef VNODE_LOCKDEBUG 1852 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1853 if (islocked_vp != 1) 1854 panic("vop_listextattr: vp: locked %d, expected %d", islocked_vp, 1); 1855 #endif 1856 a.a_attrnamespace = attrnamespace; 1857 a.a_uio = uio; 1858 a.a_size = size; 1859 a.a_cred = cred; 1860 a.a_p = p; 1861 return (VCALL(vp, VOFFSET(vop_listextattr), &a)); 1862 } 1863 #endif 1864 1865 const int vop_openextattr_vp_offsets[] = { 1866 VOPARG_OFFSETOF(struct vop_openextattr_args,a_vp), 1867 VDESC_NO_OFFSET 1868 }; 1869 const struct vnodeop_desc vop_openextattr_desc = { 1870 46, 1871 "vop_openextattr", 1872 0, 1873 vop_openextattr_vp_offsets, 1874 VDESC_NO_OFFSET, 1875 VOPARG_OFFSETOF(struct vop_openextattr_args, a_cred), 1876 VOPARG_OFFSETOF(struct vop_openextattr_args, a_p), 1877 VDESC_NO_OFFSET, 1878 NULL, 1879 }; 1880 #ifdef VNODE_OP_NOINLINE 1881 int 1882 VOP_OPENEXTATTR(vp, cred, p) 1883 struct vnode *vp; 1884 struct ucred *cred; 1885 struct proc *p; 1886 { 1887 struct vop_openextattr_args a; 1888 #ifdef VNODE_LOCKDEBUG 1889 int islocked_vp; 1890 #endif 1891 a.a_desc = VDESC(vop_openextattr); 1892 a.a_vp = vp; 1893 #ifdef VNODE_LOCKDEBUG 1894 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1895 if (islocked_vp != 1) 1896 panic("vop_openextattr: vp: locked %d, expected %d", islocked_vp, 1); 1897 #endif 1898 a.a_cred = cred; 1899 a.a_p = p; 1900 return (VCALL(vp, VOFFSET(vop_openextattr), &a)); 1901 } 1902 #endif 1903 1904 const int vop_deleteextattr_vp_offsets[] = { 1905 VOPARG_OFFSETOF(struct vop_deleteextattr_args,a_vp), 1906 VDESC_NO_OFFSET 1907 }; 1908 const struct vnodeop_desc vop_deleteextattr_desc = { 1909 47, 1910 "vop_deleteextattr", 1911 0, 1912 vop_deleteextattr_vp_offsets, 1913 VDESC_NO_OFFSET, 1914 VOPARG_OFFSETOF(struct vop_deleteextattr_args, a_cred), 1915 VOPARG_OFFSETOF(struct vop_deleteextattr_args, a_p), 1916 VDESC_NO_OFFSET, 1917 NULL, 1918 }; 1919 #ifdef VNODE_OP_NOINLINE 1920 int 1921 VOP_DELETEEXTATTR(vp, attrnamespace, name, cred, p) 1922 struct vnode *vp; 1923 int attrnamespace; 1924 const char *name; 1925 struct ucred *cred; 1926 struct proc *p; 1927 { 1928 struct vop_deleteextattr_args a; 1929 #ifdef VNODE_LOCKDEBUG 1930 int islocked_vp; 1931 #endif 1932 a.a_desc = VDESC(vop_deleteextattr); 1933 a.a_vp = vp; 1934 #ifdef VNODE_LOCKDEBUG 1935 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1936 if (islocked_vp != 1) 1937 panic("vop_deleteextattr: vp: locked %d, expected %d", islocked_vp, 1); 1938 #endif 1939 a.a_attrnamespace = attrnamespace; 1940 a.a_name = name; 1941 a.a_cred = cred; 1942 a.a_p = p; 1943 return (VCALL(vp, VOFFSET(vop_deleteextattr), &a)); 1944 } 1945 #endif 1946 1947 const int vop_setextattr_vp_offsets[] = { 1948 VOPARG_OFFSETOF(struct vop_setextattr_args,a_vp), 1949 VDESC_NO_OFFSET 1950 }; 1951 const struct vnodeop_desc vop_setextattr_desc = { 1952 48, 1953 "vop_setextattr", 1954 0, 1955 vop_setextattr_vp_offsets, 1956 VDESC_NO_OFFSET, 1957 VOPARG_OFFSETOF(struct vop_setextattr_args, a_cred), 1958 VOPARG_OFFSETOF(struct vop_setextattr_args, a_p), 1959 VDESC_NO_OFFSET, 1960 NULL, 1961 }; 1962 #ifdef VNODE_OP_NOINLINE 1963 int 1964 VOP_SETEXTATTR(vp, attrnamespace, name, uio, cred, p) 1965 struct vnode *vp; 1966 int attrnamespace; 1967 const char *name; 1968 struct uio *uio; 1969 struct ucred *cred; 1970 struct proc *p; 1971 { 1972 struct vop_setextattr_args a; 1973 #ifdef VNODE_LOCKDEBUG 1974 int islocked_vp; 1975 #endif 1976 a.a_desc = VDESC(vop_setextattr); 1977 a.a_vp = vp; 1978 #ifdef VNODE_LOCKDEBUG 1979 islocked_vp = (vp->v_flag & VLOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1980 if (islocked_vp != 1) 1981 panic("vop_setextattr: vp: locked %d, expected %d", islocked_vp, 1); 1982 #endif 1983 a.a_attrnamespace = attrnamespace; 1984 a.a_name = name; 1985 a.a_uio = uio; 1986 a.a_cred = cred; 1987 a.a_p = p; 1988 return (VCALL(vp, VOFFSET(vop_setextattr), &a)); 1989 } 1990 #endif 1991 1992 /* End of special cases. */ 1993 1994 const struct vnodeop_desc * const vfs_op_descs[] = { 1995 &vop_default_desc, /* MUST BE FIRST */ 1996 &vop_bwrite_desc, /* XXX: SPECIAL CASE */ 1997 1998 &vop_lookup_desc, 1999 &vop_create_desc, 2000 &vop_mknod_desc, 2001 &vop_open_desc, 2002 &vop_close_desc, 2003 &vop_access_desc, 2004 &vop_getattr_desc, 2005 &vop_setattr_desc, 2006 &vop_read_desc, 2007 &vop_write_desc, 2008 &vop_ioctl_desc, 2009 &vop_fcntl_desc, 2010 &vop_poll_desc, 2011 &vop_kqfilter_desc, 2012 &vop_revoke_desc, 2013 &vop_mmap_desc, 2014 &vop_fsync_desc, 2015 &vop_seek_desc, 2016 &vop_remove_desc, 2017 &vop_link_desc, 2018 &vop_rename_desc, 2019 &vop_mkdir_desc, 2020 &vop_rmdir_desc, 2021 &vop_symlink_desc, 2022 &vop_readdir_desc, 2023 &vop_readlink_desc, 2024 &vop_abortop_desc, 2025 &vop_inactive_desc, 2026 &vop_reclaim_desc, 2027 &vop_lock_desc, 2028 &vop_unlock_desc, 2029 &vop_bmap_desc, 2030 &vop_strategy_desc, 2031 &vop_print_desc, 2032 &vop_islocked_desc, 2033 &vop_pathconf_desc, 2034 &vop_advlock_desc, 2035 &vop_lease_desc, 2036 &vop_whiteout_desc, 2037 &vop_getpages_desc, 2038 &vop_putpages_desc, 2039 &vop_closeextattr_desc, 2040 &vop_getextattr_desc, 2041 &vop_listextattr_desc, 2042 &vop_openextattr_desc, 2043 &vop_deleteextattr_desc, 2044 &vop_setextattr_desc, 2045 NULL 2046 }; 2047 2048
Indexes created Mon Sep 22 10:09:38 GMT 2025