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