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