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