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