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