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