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