vnode_if.c revision 1.77
1 /* $NetBSD: vnode_if.c,v 1.77 2008/07/31 05:38:05 simonb 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.57 2008/01/25 14:32:15 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.77 2008/07/31 05:38:05 simonb 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 806 if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); } 807 return error; 808 } 809 810 const int vop_seek_vp_offsets[] = { 811 VOPARG_OFFSETOF(struct vop_seek_args,a_vp), 812 VDESC_NO_OFFSET 813 }; 814 const struct vnodeop_desc vop_seek_desc = { 815 VOP_SEEK_DESCOFFSET, 816 "vop_seek", 817 0, 818 vop_seek_vp_offsets, 819 VDESC_NO_OFFSET, 820 VOPARG_OFFSETOF(struct vop_seek_args, a_cred), 821 VDESC_NO_OFFSET, 822 NULL, 823 }; 824 int 825 VOP_SEEK(struct vnode *vp, 826 off_t oldoff, 827 off_t newoff, 828 kauth_cred_t cred) 829 { 830 int error; 831 bool mpsafe; 832 struct vop_seek_args a; 833 #ifdef VNODE_LOCKDEBUG 834 #endif 835 a.a_desc = VDESC(vop_seek); 836 a.a_vp = vp; 837 a.a_oldoff = oldoff; 838 a.a_newoff = newoff; 839 a.a_cred = cred; 840 mpsafe = (vp->v_vflag & VV_MPSAFE); 841 if (!mpsafe) { KERNEL_LOCK(1, curlwp); } 842 error = (VCALL(vp, VOFFSET(vop_seek), &a)); 843 if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); } 844 return error; 845 } 846 847 const int vop_remove_vp_offsets[] = { 848 VOPARG_OFFSETOF(struct vop_remove_args,a_dvp), 849 VOPARG_OFFSETOF(struct vop_remove_args,a_vp), 850 VDESC_NO_OFFSET 851 }; 852 const struct vnodeop_desc vop_remove_desc = { 853 VOP_REMOVE_DESCOFFSET, 854 "vop_remove", 855 0 | VDESC_VP0_WILLPUT | VDESC_VP1_WILLPUT, 856 vop_remove_vp_offsets, 857 VDESC_NO_OFFSET, 858 VDESC_NO_OFFSET, 859 VOPARG_OFFSETOF(struct vop_remove_args, a_cnp), 860 NULL, 861 }; 862 int 863 VOP_REMOVE(struct vnode *dvp, 864 struct vnode *vp, 865 struct componentname *cnp) 866 { 867 int error; 868 bool mpsafe; 869 struct vop_remove_args a; 870 #ifdef VNODE_LOCKDEBUG 871 int islocked_dvp; 872 int islocked_vp; 873 #endif 874 a.a_desc = VDESC(vop_remove); 875 a.a_dvp = dvp; 876 #ifdef VNODE_LOCKDEBUG 877 islocked_dvp = (dvp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1; 878 if (islocked_dvp != 1) 879 panic("vop_remove: dvp: locked %d, expected %d", islocked_dvp, 1); 880 #endif 881 a.a_vp = vp; 882 #ifdef VNODE_LOCKDEBUG 883 islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 884 if (islocked_vp != 1) 885 panic("vop_remove: vp: locked %d, expected %d", islocked_vp, 1); 886 #endif 887 a.a_cnp = cnp; 888 mpsafe = (dvp->v_vflag & VV_MPSAFE); 889 if (!mpsafe) { KERNEL_LOCK(1, curlwp); } 890 error = (VCALL(dvp, VOFFSET(vop_remove), &a)); 891 if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); } 892 return error; 893 } 894 895 const int vop_link_vp_offsets[] = { 896 VOPARG_OFFSETOF(struct vop_link_args,a_dvp), 897 VOPARG_OFFSETOF(struct vop_link_args,a_vp), 898 VDESC_NO_OFFSET 899 }; 900 const struct vnodeop_desc vop_link_desc = { 901 VOP_LINK_DESCOFFSET, 902 "vop_link", 903 0 | VDESC_VP0_WILLPUT, 904 vop_link_vp_offsets, 905 VDESC_NO_OFFSET, 906 VDESC_NO_OFFSET, 907 VOPARG_OFFSETOF(struct vop_link_args, a_cnp), 908 NULL, 909 }; 910 int 911 VOP_LINK(struct vnode *dvp, 912 struct vnode *vp, 913 struct componentname *cnp) 914 { 915 int error; 916 bool mpsafe; 917 struct vop_link_args a; 918 #ifdef VNODE_LOCKDEBUG 919 int islocked_dvp; 920 int islocked_vp; 921 #endif 922 a.a_desc = VDESC(vop_link); 923 a.a_dvp = dvp; 924 #ifdef VNODE_LOCKDEBUG 925 islocked_dvp = (dvp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1; 926 if (islocked_dvp != 1) 927 panic("vop_link: dvp: locked %d, expected %d", islocked_dvp, 1); 928 #endif 929 a.a_vp = vp; 930 #ifdef VNODE_LOCKDEBUG 931 islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0; 932 if (islocked_vp != 0) 933 panic("vop_link: vp: locked %d, expected %d", islocked_vp, 0); 934 #endif 935 a.a_cnp = cnp; 936 mpsafe = (dvp->v_vflag & VV_MPSAFE); 937 if (!mpsafe) { KERNEL_LOCK(1, curlwp); } 938 error = (VCALL(dvp, VOFFSET(vop_link), &a)); 939 if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); } 940 return error; 941 } 942 943 const int vop_rename_vp_offsets[] = { 944 VOPARG_OFFSETOF(struct vop_rename_args,a_fdvp), 945 VOPARG_OFFSETOF(struct vop_rename_args,a_fvp), 946 VOPARG_OFFSETOF(struct vop_rename_args,a_tdvp), 947 VOPARG_OFFSETOF(struct vop_rename_args,a_tvp), 948 VDESC_NO_OFFSET 949 }; 950 const struct vnodeop_desc vop_rename_desc = { 951 VOP_RENAME_DESCOFFSET, 952 "vop_rename", 953 0 | VDESC_VP0_WILLRELE | VDESC_VP1_WILLRELE | VDESC_VP2_WILLPUT | VDESC_VP3_WILLPUT, 954 vop_rename_vp_offsets, 955 VDESC_NO_OFFSET, 956 VDESC_NO_OFFSET, 957 VOPARG_OFFSETOF(struct vop_rename_args, a_fcnp), 958 NULL, 959 }; 960 int 961 VOP_RENAME(struct vnode *fdvp, 962 struct vnode *fvp, 963 struct componentname *fcnp, 964 struct vnode *tdvp, 965 struct vnode *tvp, 966 struct componentname *tcnp) 967 { 968 int error; 969 bool mpsafe; 970 struct vop_rename_args a; 971 #ifdef VNODE_LOCKDEBUG 972 int islocked_fdvp; 973 int islocked_fvp; 974 int islocked_tdvp; 975 #endif 976 a.a_desc = VDESC(vop_rename); 977 a.a_fdvp = fdvp; 978 #ifdef VNODE_LOCKDEBUG 979 islocked_fdvp = (fdvp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(fdvp) == LK_EXCLUSIVE) : 0; 980 if (islocked_fdvp != 0) 981 panic("vop_rename: fdvp: locked %d, expected %d", islocked_fdvp, 0); 982 #endif 983 a.a_fvp = fvp; 984 #ifdef VNODE_LOCKDEBUG 985 islocked_fvp = (fvp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(fvp) == LK_EXCLUSIVE) : 0; 986 if (islocked_fvp != 0) 987 panic("vop_rename: fvp: locked %d, expected %d", islocked_fvp, 0); 988 #endif 989 a.a_fcnp = fcnp; 990 a.a_tdvp = tdvp; 991 #ifdef VNODE_LOCKDEBUG 992 islocked_tdvp = (tdvp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(tdvp) == LK_EXCLUSIVE) : 1; 993 if (islocked_tdvp != 1) 994 panic("vop_rename: tdvp: locked %d, expected %d", islocked_tdvp, 1); 995 #endif 996 a.a_tvp = tvp; 997 a.a_tcnp = tcnp; 998 mpsafe = (fdvp->v_vflag & VV_MPSAFE); 999 if (!mpsafe) { KERNEL_LOCK(1, curlwp); } 1000 error = (VCALL(fdvp, VOFFSET(vop_rename), &a)); 1001 if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); } 1002 return error; 1003 } 1004 1005 const int vop_mkdir_vp_offsets[] = { 1006 VOPARG_OFFSETOF(struct vop_mkdir_args,a_dvp), 1007 VDESC_NO_OFFSET 1008 }; 1009 const struct vnodeop_desc vop_mkdir_desc = { 1010 VOP_MKDIR_DESCOFFSET, 1011 "vop_mkdir", 1012 0 | VDESC_VP0_WILLPUT, 1013 vop_mkdir_vp_offsets, 1014 VOPARG_OFFSETOF(struct vop_mkdir_args, a_vpp), 1015 VDESC_NO_OFFSET, 1016 VOPARG_OFFSETOF(struct vop_mkdir_args, a_cnp), 1017 NULL, 1018 }; 1019 int 1020 VOP_MKDIR(struct vnode *dvp, 1021 struct vnode **vpp, 1022 struct componentname *cnp, 1023 struct vattr *vap) 1024 { 1025 int error; 1026 bool mpsafe; 1027 struct vop_mkdir_args a; 1028 #ifdef VNODE_LOCKDEBUG 1029 int islocked_dvp; 1030 #endif 1031 a.a_desc = VDESC(vop_mkdir); 1032 a.a_dvp = dvp; 1033 #ifdef VNODE_LOCKDEBUG 1034 islocked_dvp = (dvp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1; 1035 if (islocked_dvp != 1) 1036 panic("vop_mkdir: dvp: locked %d, expected %d", islocked_dvp, 1); 1037 #endif 1038 a.a_vpp = vpp; 1039 a.a_cnp = cnp; 1040 a.a_vap = vap; 1041 mpsafe = (dvp->v_vflag & VV_MPSAFE); 1042 if (!mpsafe) { KERNEL_LOCK(1, curlwp); } 1043 error = (VCALL(dvp, VOFFSET(vop_mkdir), &a)); 1044 if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); } 1045 #ifdef DIAGNOSTIC 1046 if (error == 0) 1047 KASSERT((*vpp)->v_size != VSIZENOTSET 1048 && (*vpp)->v_writesize != VSIZENOTSET); 1049 #endif /* DIAGNOSTIC */ 1050 return error; 1051 } 1052 1053 const int vop_rmdir_vp_offsets[] = { 1054 VOPARG_OFFSETOF(struct vop_rmdir_args,a_dvp), 1055 VOPARG_OFFSETOF(struct vop_rmdir_args,a_vp), 1056 VDESC_NO_OFFSET 1057 }; 1058 const struct vnodeop_desc vop_rmdir_desc = { 1059 VOP_RMDIR_DESCOFFSET, 1060 "vop_rmdir", 1061 0 | VDESC_VP0_WILLPUT | VDESC_VP1_WILLPUT, 1062 vop_rmdir_vp_offsets, 1063 VDESC_NO_OFFSET, 1064 VDESC_NO_OFFSET, 1065 VOPARG_OFFSETOF(struct vop_rmdir_args, a_cnp), 1066 NULL, 1067 }; 1068 int 1069 VOP_RMDIR(struct vnode *dvp, 1070 struct vnode *vp, 1071 struct componentname *cnp) 1072 { 1073 int error; 1074 bool mpsafe; 1075 struct vop_rmdir_args a; 1076 #ifdef VNODE_LOCKDEBUG 1077 int islocked_dvp; 1078 int islocked_vp; 1079 #endif 1080 a.a_desc = VDESC(vop_rmdir); 1081 a.a_dvp = dvp; 1082 #ifdef VNODE_LOCKDEBUG 1083 islocked_dvp = (dvp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1; 1084 if (islocked_dvp != 1) 1085 panic("vop_rmdir: dvp: locked %d, expected %d", islocked_dvp, 1); 1086 #endif 1087 a.a_vp = vp; 1088 #ifdef VNODE_LOCKDEBUG 1089 islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1090 if (islocked_vp != 1) 1091 panic("vop_rmdir: vp: locked %d, expected %d", islocked_vp, 1); 1092 #endif 1093 a.a_cnp = cnp; 1094 mpsafe = (dvp->v_vflag & VV_MPSAFE); 1095 if (!mpsafe) { KERNEL_LOCK(1, curlwp); } 1096 error = (VCALL(dvp, VOFFSET(vop_rmdir), &a)); 1097 if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); } 1098 return error; 1099 } 1100 1101 const int vop_symlink_vp_offsets[] = { 1102 VOPARG_OFFSETOF(struct vop_symlink_args,a_dvp), 1103 VDESC_NO_OFFSET 1104 }; 1105 const struct vnodeop_desc vop_symlink_desc = { 1106 VOP_SYMLINK_DESCOFFSET, 1107 "vop_symlink", 1108 0 | VDESC_VP0_WILLPUT, 1109 vop_symlink_vp_offsets, 1110 VOPARG_OFFSETOF(struct vop_symlink_args, a_vpp), 1111 VDESC_NO_OFFSET, 1112 VOPARG_OFFSETOF(struct vop_symlink_args, a_cnp), 1113 NULL, 1114 }; 1115 int 1116 VOP_SYMLINK(struct vnode *dvp, 1117 struct vnode **vpp, 1118 struct componentname *cnp, 1119 struct vattr *vap, 1120 char *target) 1121 { 1122 int error; 1123 bool mpsafe; 1124 struct vop_symlink_args a; 1125 #ifdef VNODE_LOCKDEBUG 1126 int islocked_dvp; 1127 #endif 1128 a.a_desc = VDESC(vop_symlink); 1129 a.a_dvp = dvp; 1130 #ifdef VNODE_LOCKDEBUG 1131 islocked_dvp = (dvp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1; 1132 if (islocked_dvp != 1) 1133 panic("vop_symlink: dvp: locked %d, expected %d", islocked_dvp, 1); 1134 #endif 1135 a.a_vpp = vpp; 1136 a.a_cnp = cnp; 1137 a.a_vap = vap; 1138 a.a_target = target; 1139 mpsafe = (dvp->v_vflag & VV_MPSAFE); 1140 if (!mpsafe) { KERNEL_LOCK(1, curlwp); } 1141 error = (VCALL(dvp, VOFFSET(vop_symlink), &a)); 1142 if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); } 1143 #ifdef DIAGNOSTIC 1144 if (error == 0) 1145 KASSERT((*vpp)->v_size != VSIZENOTSET 1146 && (*vpp)->v_writesize != VSIZENOTSET); 1147 #endif /* DIAGNOSTIC */ 1148 return error; 1149 } 1150 1151 const int vop_readdir_vp_offsets[] = { 1152 VOPARG_OFFSETOF(struct vop_readdir_args,a_vp), 1153 VDESC_NO_OFFSET 1154 }; 1155 const struct vnodeop_desc vop_readdir_desc = { 1156 VOP_READDIR_DESCOFFSET, 1157 "vop_readdir", 1158 0, 1159 vop_readdir_vp_offsets, 1160 VDESC_NO_OFFSET, 1161 VOPARG_OFFSETOF(struct vop_readdir_args, a_cred), 1162 VDESC_NO_OFFSET, 1163 NULL, 1164 }; 1165 int 1166 VOP_READDIR(struct vnode *vp, 1167 struct uio *uio, 1168 kauth_cred_t cred, 1169 int *eofflag, 1170 off_t **cookies, 1171 int *ncookies) 1172 { 1173 int error; 1174 bool mpsafe; 1175 struct vop_readdir_args a; 1176 #ifdef VNODE_LOCKDEBUG 1177 int islocked_vp; 1178 #endif 1179 a.a_desc = VDESC(vop_readdir); 1180 a.a_vp = vp; 1181 #ifdef VNODE_LOCKDEBUG 1182 islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1183 if (islocked_vp != 1) 1184 panic("vop_readdir: vp: locked %d, expected %d", islocked_vp, 1); 1185 #endif 1186 a.a_uio = uio; 1187 a.a_cred = cred; 1188 a.a_eofflag = eofflag; 1189 a.a_cookies = cookies; 1190 a.a_ncookies = ncookies; 1191 mpsafe = (vp->v_vflag & VV_MPSAFE); 1192 if (!mpsafe) { KERNEL_LOCK(1, curlwp); } 1193 error = (VCALL(vp, VOFFSET(vop_readdir), &a)); 1194 if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); } 1195 return error; 1196 } 1197 1198 const int vop_readlink_vp_offsets[] = { 1199 VOPARG_OFFSETOF(struct vop_readlink_args,a_vp), 1200 VDESC_NO_OFFSET 1201 }; 1202 const struct vnodeop_desc vop_readlink_desc = { 1203 VOP_READLINK_DESCOFFSET, 1204 "vop_readlink", 1205 0, 1206 vop_readlink_vp_offsets, 1207 VDESC_NO_OFFSET, 1208 VOPARG_OFFSETOF(struct vop_readlink_args, a_cred), 1209 VDESC_NO_OFFSET, 1210 NULL, 1211 }; 1212 int 1213 VOP_READLINK(struct vnode *vp, 1214 struct uio *uio, 1215 kauth_cred_t cred) 1216 { 1217 int error; 1218 bool mpsafe; 1219 struct vop_readlink_args a; 1220 #ifdef VNODE_LOCKDEBUG 1221 int islocked_vp; 1222 #endif 1223 a.a_desc = VDESC(vop_readlink); 1224 a.a_vp = vp; 1225 #ifdef VNODE_LOCKDEBUG 1226 islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1227 if (islocked_vp != 1) 1228 panic("vop_readlink: vp: locked %d, expected %d", islocked_vp, 1); 1229 #endif 1230 a.a_uio = uio; 1231 a.a_cred = cred; 1232 mpsafe = (vp->v_vflag & VV_MPSAFE); 1233 if (!mpsafe) { KERNEL_LOCK(1, curlwp); } 1234 error = (VCALL(vp, VOFFSET(vop_readlink), &a)); 1235 if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); } 1236 return error; 1237 } 1238 1239 const int vop_abortop_vp_offsets[] = { 1240 VOPARG_OFFSETOF(struct vop_abortop_args,a_dvp), 1241 VDESC_NO_OFFSET 1242 }; 1243 const struct vnodeop_desc vop_abortop_desc = { 1244 VOP_ABORTOP_DESCOFFSET, 1245 "vop_abortop", 1246 0, 1247 vop_abortop_vp_offsets, 1248 VDESC_NO_OFFSET, 1249 VDESC_NO_OFFSET, 1250 VOPARG_OFFSETOF(struct vop_abortop_args, a_cnp), 1251 NULL, 1252 }; 1253 int 1254 VOP_ABORTOP(struct vnode *dvp, 1255 struct componentname *cnp) 1256 { 1257 int error; 1258 bool mpsafe; 1259 struct vop_abortop_args a; 1260 #ifdef VNODE_LOCKDEBUG 1261 #endif 1262 a.a_desc = VDESC(vop_abortop); 1263 a.a_dvp = dvp; 1264 a.a_cnp = cnp; 1265 mpsafe = (dvp->v_vflag & VV_MPSAFE); 1266 if (!mpsafe) { KERNEL_LOCK(1, curlwp); } 1267 error = (VCALL(dvp, VOFFSET(vop_abortop), &a)); 1268 if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); } 1269 return error; 1270 } 1271 1272 const int vop_inactive_vp_offsets[] = { 1273 VOPARG_OFFSETOF(struct vop_inactive_args,a_vp), 1274 VDESC_NO_OFFSET 1275 }; 1276 const struct vnodeop_desc vop_inactive_desc = { 1277 VOP_INACTIVE_DESCOFFSET, 1278 "vop_inactive", 1279 0 | VDESC_VP0_WILLUNLOCK, 1280 vop_inactive_vp_offsets, 1281 VDESC_NO_OFFSET, 1282 VDESC_NO_OFFSET, 1283 VDESC_NO_OFFSET, 1284 NULL, 1285 }; 1286 int 1287 VOP_INACTIVE(struct vnode *vp, 1288 bool *recycle) 1289 { 1290 int error; 1291 bool mpsafe; 1292 struct vop_inactive_args a; 1293 #ifdef VNODE_LOCKDEBUG 1294 int islocked_vp; 1295 #endif 1296 a.a_desc = VDESC(vop_inactive); 1297 a.a_vp = vp; 1298 #ifdef VNODE_LOCKDEBUG 1299 islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1300 if (islocked_vp != 1) 1301 panic("vop_inactive: vp: locked %d, expected %d", islocked_vp, 1); 1302 #endif 1303 a.a_recycle = recycle; 1304 mpsafe = (vp->v_vflag & VV_MPSAFE); 1305 if (!mpsafe) { KERNEL_LOCK(1, curlwp); } 1306 error = (VCALL(vp, VOFFSET(vop_inactive), &a)); 1307 if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); } 1308 return error; 1309 } 1310 1311 const int vop_reclaim_vp_offsets[] = { 1312 VOPARG_OFFSETOF(struct vop_reclaim_args,a_vp), 1313 VDESC_NO_OFFSET 1314 }; 1315 const struct vnodeop_desc vop_reclaim_desc = { 1316 VOP_RECLAIM_DESCOFFSET, 1317 "vop_reclaim", 1318 0, 1319 vop_reclaim_vp_offsets, 1320 VDESC_NO_OFFSET, 1321 VDESC_NO_OFFSET, 1322 VDESC_NO_OFFSET, 1323 NULL, 1324 }; 1325 int 1326 VOP_RECLAIM(struct vnode *vp) 1327 { 1328 int error; 1329 bool mpsafe; 1330 struct vop_reclaim_args a; 1331 #ifdef VNODE_LOCKDEBUG 1332 int islocked_vp; 1333 #endif 1334 a.a_desc = VDESC(vop_reclaim); 1335 a.a_vp = vp; 1336 #ifdef VNODE_LOCKDEBUG 1337 islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0; 1338 if (islocked_vp != 0) 1339 panic("vop_reclaim: vp: locked %d, expected %d", islocked_vp, 0); 1340 #endif 1341 mpsafe = (vp->v_vflag & VV_MPSAFE); 1342 if (!mpsafe) { KERNEL_LOCK(1, curlwp); } 1343 error = (VCALL(vp, VOFFSET(vop_reclaim), &a)); 1344 if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); } 1345 return error; 1346 } 1347 1348 const int vop_lock_vp_offsets[] = { 1349 VOPARG_OFFSETOF(struct vop_lock_args,a_vp), 1350 VDESC_NO_OFFSET 1351 }; 1352 const struct vnodeop_desc vop_lock_desc = { 1353 VOP_LOCK_DESCOFFSET, 1354 "vop_lock", 1355 0, 1356 vop_lock_vp_offsets, 1357 VDESC_NO_OFFSET, 1358 VDESC_NO_OFFSET, 1359 VDESC_NO_OFFSET, 1360 NULL, 1361 }; 1362 int 1363 VOP_LOCK(struct vnode *vp, 1364 int flags) 1365 { 1366 int error; 1367 bool mpsafe; 1368 struct vop_lock_args a; 1369 #ifdef VNODE_LOCKDEBUG 1370 int islocked_vp; 1371 #endif 1372 a.a_desc = VDESC(vop_lock); 1373 a.a_vp = vp; 1374 #ifdef VNODE_LOCKDEBUG 1375 islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0; 1376 if (islocked_vp != 0) 1377 panic("vop_lock: vp: locked %d, expected %d", islocked_vp, 0); 1378 #endif 1379 a.a_flags = flags; 1380 mpsafe = (vp->v_vflag & VV_MPSAFE); 1381 if (!mpsafe) { KERNEL_LOCK(1, curlwp); } 1382 error = (VCALL(vp, VOFFSET(vop_lock), &a)); 1383 if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); } 1384 return error; 1385 } 1386 1387 const int vop_unlock_vp_offsets[] = { 1388 VOPARG_OFFSETOF(struct vop_unlock_args,a_vp), 1389 VDESC_NO_OFFSET 1390 }; 1391 const struct vnodeop_desc vop_unlock_desc = { 1392 VOP_UNLOCK_DESCOFFSET, 1393 "vop_unlock", 1394 0, 1395 vop_unlock_vp_offsets, 1396 VDESC_NO_OFFSET, 1397 VDESC_NO_OFFSET, 1398 VDESC_NO_OFFSET, 1399 NULL, 1400 }; 1401 int 1402 VOP_UNLOCK(struct vnode *vp, 1403 int flags) 1404 { 1405 int error; 1406 bool mpsafe; 1407 struct vop_unlock_args a; 1408 #ifdef VNODE_LOCKDEBUG 1409 int islocked_vp; 1410 #endif 1411 a.a_desc = VDESC(vop_unlock); 1412 a.a_vp = vp; 1413 #ifdef VNODE_LOCKDEBUG 1414 islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1415 if (islocked_vp != 1) 1416 panic("vop_unlock: vp: locked %d, expected %d", islocked_vp, 1); 1417 #endif 1418 a.a_flags = flags; 1419 mpsafe = (vp->v_vflag & VV_MPSAFE); 1420 if (!mpsafe) { KERNEL_LOCK(1, curlwp); } 1421 error = (VCALL(vp, VOFFSET(vop_unlock), &a)); 1422 if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); } 1423 return error; 1424 } 1425 1426 const int vop_bmap_vp_offsets[] = { 1427 VOPARG_OFFSETOF(struct vop_bmap_args,a_vp), 1428 VDESC_NO_OFFSET 1429 }; 1430 const struct vnodeop_desc vop_bmap_desc = { 1431 VOP_BMAP_DESCOFFSET, 1432 "vop_bmap", 1433 0, 1434 vop_bmap_vp_offsets, 1435 VOPARG_OFFSETOF(struct vop_bmap_args, a_vpp), 1436 VDESC_NO_OFFSET, 1437 VDESC_NO_OFFSET, 1438 NULL, 1439 }; 1440 int 1441 VOP_BMAP(struct vnode *vp, 1442 daddr_t bn, 1443 struct vnode **vpp, 1444 daddr_t *bnp, 1445 int *runp) 1446 { 1447 int error; 1448 bool mpsafe; 1449 struct vop_bmap_args a; 1450 #ifdef VNODE_LOCKDEBUG 1451 #endif 1452 a.a_desc = VDESC(vop_bmap); 1453 a.a_vp = vp; 1454 a.a_bn = bn; 1455 a.a_vpp = vpp; 1456 a.a_bnp = bnp; 1457 a.a_runp = runp; 1458 mpsafe = (vp->v_vflag & VV_MPSAFE); 1459 if (!mpsafe) { KERNEL_LOCK(1, curlwp); } 1460 error = (VCALL(vp, VOFFSET(vop_bmap), &a)); 1461 if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); } 1462 return error; 1463 } 1464 1465 const int vop_strategy_vp_offsets[] = { 1466 VOPARG_OFFSETOF(struct vop_strategy_args,a_vp), 1467 VDESC_NO_OFFSET 1468 }; 1469 const struct vnodeop_desc vop_strategy_desc = { 1470 VOP_STRATEGY_DESCOFFSET, 1471 "vop_strategy", 1472 0, 1473 vop_strategy_vp_offsets, 1474 VDESC_NO_OFFSET, 1475 VDESC_NO_OFFSET, 1476 VDESC_NO_OFFSET, 1477 NULL, 1478 }; 1479 int 1480 VOP_STRATEGY(struct vnode *vp, 1481 struct buf *bp) 1482 { 1483 int error; 1484 bool mpsafe; 1485 struct vop_strategy_args a; 1486 #ifdef VNODE_LOCKDEBUG 1487 #endif 1488 a.a_desc = VDESC(vop_strategy); 1489 a.a_vp = vp; 1490 a.a_bp = bp; 1491 mpsafe = (vp->v_vflag & VV_MPSAFE); 1492 if (!mpsafe) { KERNEL_LOCK(1, curlwp); } 1493 error = (VCALL(vp, VOFFSET(vop_strategy), &a)); 1494 if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); } 1495 return error; 1496 } 1497 1498 const int vop_print_vp_offsets[] = { 1499 VOPARG_OFFSETOF(struct vop_print_args,a_vp), 1500 VDESC_NO_OFFSET 1501 }; 1502 const struct vnodeop_desc vop_print_desc = { 1503 VOP_PRINT_DESCOFFSET, 1504 "vop_print", 1505 0, 1506 vop_print_vp_offsets, 1507 VDESC_NO_OFFSET, 1508 VDESC_NO_OFFSET, 1509 VDESC_NO_OFFSET, 1510 NULL, 1511 }; 1512 int 1513 VOP_PRINT(struct vnode *vp) 1514 { 1515 int error; 1516 bool mpsafe; 1517 struct vop_print_args a; 1518 #ifdef VNODE_LOCKDEBUG 1519 #endif 1520 a.a_desc = VDESC(vop_print); 1521 a.a_vp = vp; 1522 mpsafe = (vp->v_vflag & VV_MPSAFE); 1523 if (!mpsafe) { KERNEL_LOCK(1, curlwp); } 1524 error = (VCALL(vp, VOFFSET(vop_print), &a)); 1525 if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); } 1526 return error; 1527 } 1528 1529 const int vop_islocked_vp_offsets[] = { 1530 VOPARG_OFFSETOF(struct vop_islocked_args,a_vp), 1531 VDESC_NO_OFFSET 1532 }; 1533 const struct vnodeop_desc vop_islocked_desc = { 1534 VOP_ISLOCKED_DESCOFFSET, 1535 "vop_islocked", 1536 0, 1537 vop_islocked_vp_offsets, 1538 VDESC_NO_OFFSET, 1539 VDESC_NO_OFFSET, 1540 VDESC_NO_OFFSET, 1541 NULL, 1542 }; 1543 int 1544 VOP_ISLOCKED(struct vnode *vp) 1545 { 1546 int error; 1547 bool mpsafe; 1548 struct vop_islocked_args a; 1549 #ifdef VNODE_LOCKDEBUG 1550 #endif 1551 a.a_desc = VDESC(vop_islocked); 1552 a.a_vp = vp; 1553 mpsafe = (vp->v_vflag & VV_MPSAFE); 1554 if (!mpsafe) { KERNEL_LOCK(1, curlwp); } 1555 error = (VCALL(vp, VOFFSET(vop_islocked), &a)); 1556 if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); } 1557 return error; 1558 } 1559 1560 const int vop_pathconf_vp_offsets[] = { 1561 VOPARG_OFFSETOF(struct vop_pathconf_args,a_vp), 1562 VDESC_NO_OFFSET 1563 }; 1564 const struct vnodeop_desc vop_pathconf_desc = { 1565 VOP_PATHCONF_DESCOFFSET, 1566 "vop_pathconf", 1567 0, 1568 vop_pathconf_vp_offsets, 1569 VDESC_NO_OFFSET, 1570 VDESC_NO_OFFSET, 1571 VDESC_NO_OFFSET, 1572 NULL, 1573 }; 1574 int 1575 VOP_PATHCONF(struct vnode *vp, 1576 int name, 1577 register_t *retval) 1578 { 1579 int error; 1580 bool mpsafe; 1581 struct vop_pathconf_args a; 1582 #ifdef VNODE_LOCKDEBUG 1583 int islocked_vp; 1584 #endif 1585 a.a_desc = VDESC(vop_pathconf); 1586 a.a_vp = vp; 1587 #ifdef VNODE_LOCKDEBUG 1588 islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1589 if (islocked_vp != 1) 1590 panic("vop_pathconf: vp: locked %d, expected %d", islocked_vp, 1); 1591 #endif 1592 a.a_name = name; 1593 a.a_retval = retval; 1594 mpsafe = (vp->v_vflag & VV_MPSAFE); 1595 if (!mpsafe) { KERNEL_LOCK(1, curlwp); } 1596 error = (VCALL(vp, VOFFSET(vop_pathconf), &a)); 1597 if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); } 1598 return error; 1599 } 1600 1601 const int vop_advlock_vp_offsets[] = { 1602 VOPARG_OFFSETOF(struct vop_advlock_args,a_vp), 1603 VDESC_NO_OFFSET 1604 }; 1605 const struct vnodeop_desc vop_advlock_desc = { 1606 VOP_ADVLOCK_DESCOFFSET, 1607 "vop_advlock", 1608 0, 1609 vop_advlock_vp_offsets, 1610 VDESC_NO_OFFSET, 1611 VDESC_NO_OFFSET, 1612 VDESC_NO_OFFSET, 1613 NULL, 1614 }; 1615 int 1616 VOP_ADVLOCK(struct vnode *vp, 1617 void *id, 1618 int op, 1619 struct flock *fl, 1620 int flags) 1621 { 1622 int error; 1623 bool mpsafe; 1624 struct vop_advlock_args a; 1625 #ifdef VNODE_LOCKDEBUG 1626 int islocked_vp; 1627 #endif 1628 a.a_desc = VDESC(vop_advlock); 1629 a.a_vp = vp; 1630 #ifdef VNODE_LOCKDEBUG 1631 islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0; 1632 if (islocked_vp != 0) 1633 panic("vop_advlock: vp: locked %d, expected %d", islocked_vp, 0); 1634 #endif 1635 a.a_id = id; 1636 a.a_op = op; 1637 a.a_fl = fl; 1638 a.a_flags = flags; 1639 mpsafe = (vp->v_vflag & VV_MPSAFE); 1640 if (!mpsafe) { KERNEL_LOCK(1, curlwp); } 1641 error = (VCALL(vp, VOFFSET(vop_advlock), &a)); 1642 if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); } 1643 return error; 1644 } 1645 1646 const int vop_whiteout_vp_offsets[] = { 1647 VOPARG_OFFSETOF(struct vop_whiteout_args,a_dvp), 1648 VDESC_NO_OFFSET 1649 }; 1650 const struct vnodeop_desc vop_whiteout_desc = { 1651 VOP_WHITEOUT_DESCOFFSET, 1652 "vop_whiteout", 1653 0, 1654 vop_whiteout_vp_offsets, 1655 VDESC_NO_OFFSET, 1656 VDESC_NO_OFFSET, 1657 VOPARG_OFFSETOF(struct vop_whiteout_args, a_cnp), 1658 NULL, 1659 }; 1660 int 1661 VOP_WHITEOUT(struct vnode *dvp, 1662 struct componentname *cnp, 1663 int flags) 1664 { 1665 int error; 1666 bool mpsafe; 1667 struct vop_whiteout_args a; 1668 #ifdef VNODE_LOCKDEBUG 1669 int islocked_dvp; 1670 #endif 1671 a.a_desc = VDESC(vop_whiteout); 1672 a.a_dvp = dvp; 1673 #ifdef VNODE_LOCKDEBUG 1674 islocked_dvp = (dvp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1; 1675 if (islocked_dvp != 1) 1676 panic("vop_whiteout: dvp: locked %d, expected %d", islocked_dvp, 1); 1677 #endif 1678 a.a_cnp = cnp; 1679 a.a_flags = flags; 1680 mpsafe = (dvp->v_vflag & VV_MPSAFE); 1681 if (!mpsafe) { KERNEL_LOCK(1, curlwp); } 1682 error = (VCALL(dvp, VOFFSET(vop_whiteout), &a)); 1683 if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); } 1684 return error; 1685 } 1686 1687 const int vop_getpages_vp_offsets[] = { 1688 VOPARG_OFFSETOF(struct vop_getpages_args,a_vp), 1689 VDESC_NO_OFFSET 1690 }; 1691 const struct vnodeop_desc vop_getpages_desc = { 1692 VOP_GETPAGES_DESCOFFSET, 1693 "vop_getpages", 1694 0, 1695 vop_getpages_vp_offsets, 1696 VDESC_NO_OFFSET, 1697 VDESC_NO_OFFSET, 1698 VDESC_NO_OFFSET, 1699 NULL, 1700 }; 1701 int 1702 VOP_GETPAGES(struct vnode *vp, 1703 voff_t offset, 1704 struct vm_page **m, 1705 int *count, 1706 int centeridx, 1707 vm_prot_t access_type, 1708 int advice, 1709 int flags) 1710 { 1711 int error; 1712 bool mpsafe; 1713 struct vop_getpages_args a; 1714 #ifdef VNODE_LOCKDEBUG 1715 #endif 1716 a.a_desc = VDESC(vop_getpages); 1717 a.a_vp = vp; 1718 a.a_offset = offset; 1719 a.a_m = m; 1720 a.a_count = count; 1721 a.a_centeridx = centeridx; 1722 a.a_access_type = access_type; 1723 a.a_advice = advice; 1724 a.a_flags = flags; 1725 mpsafe = (vp->v_vflag & VV_MPSAFE); 1726 if (!mpsafe) { KERNEL_LOCK(1, curlwp); } 1727 error = (VCALL(vp, VOFFSET(vop_getpages), &a)); 1728 if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); } 1729 return error; 1730 } 1731 1732 const int vop_putpages_vp_offsets[] = { 1733 VOPARG_OFFSETOF(struct vop_putpages_args,a_vp), 1734 VDESC_NO_OFFSET 1735 }; 1736 const struct vnodeop_desc vop_putpages_desc = { 1737 VOP_PUTPAGES_DESCOFFSET, 1738 "vop_putpages", 1739 0, 1740 vop_putpages_vp_offsets, 1741 VDESC_NO_OFFSET, 1742 VDESC_NO_OFFSET, 1743 VDESC_NO_OFFSET, 1744 NULL, 1745 }; 1746 int 1747 VOP_PUTPAGES(struct vnode *vp, 1748 voff_t offlo, 1749 voff_t offhi, 1750 int flags) 1751 { 1752 int error; 1753 bool mpsafe; 1754 struct vop_putpages_args a; 1755 #ifdef VNODE_LOCKDEBUG 1756 #endif 1757 a.a_desc = VDESC(vop_putpages); 1758 a.a_vp = vp; 1759 a.a_offlo = offlo; 1760 a.a_offhi = offhi; 1761 a.a_flags = flags; 1762 mpsafe = (vp->v_vflag & VV_MPSAFE); 1763 if (!mpsafe) { KERNEL_LOCK(1, curlwp); } 1764 error = (VCALL(vp, VOFFSET(vop_putpages), &a)); 1765 if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); } 1766 return error; 1767 } 1768 1769 const int vop_closeextattr_vp_offsets[] = { 1770 VOPARG_OFFSETOF(struct vop_closeextattr_args,a_vp), 1771 VDESC_NO_OFFSET 1772 }; 1773 const struct vnodeop_desc vop_closeextattr_desc = { 1774 VOP_CLOSEEXTATTR_DESCOFFSET, 1775 "vop_closeextattr", 1776 0, 1777 vop_closeextattr_vp_offsets, 1778 VDESC_NO_OFFSET, 1779 VOPARG_OFFSETOF(struct vop_closeextattr_args, a_cred), 1780 VDESC_NO_OFFSET, 1781 NULL, 1782 }; 1783 int 1784 VOP_CLOSEEXTATTR(struct vnode *vp, 1785 int commit, 1786 kauth_cred_t cred) 1787 { 1788 int error; 1789 bool mpsafe; 1790 struct vop_closeextattr_args a; 1791 #ifdef VNODE_LOCKDEBUG 1792 int islocked_vp; 1793 #endif 1794 a.a_desc = VDESC(vop_closeextattr); 1795 a.a_vp = vp; 1796 #ifdef VNODE_LOCKDEBUG 1797 islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1798 if (islocked_vp != 1) 1799 panic("vop_closeextattr: vp: locked %d, expected %d", islocked_vp, 1); 1800 #endif 1801 a.a_commit = commit; 1802 a.a_cred = cred; 1803 mpsafe = (vp->v_vflag & VV_MPSAFE); 1804 if (!mpsafe) { KERNEL_LOCK(1, curlwp); } 1805 error = (VCALL(vp, VOFFSET(vop_closeextattr), &a)); 1806 if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); } 1807 return error; 1808 } 1809 1810 const int vop_getextattr_vp_offsets[] = { 1811 VOPARG_OFFSETOF(struct vop_getextattr_args,a_vp), 1812 VDESC_NO_OFFSET 1813 }; 1814 const struct vnodeop_desc vop_getextattr_desc = { 1815 VOP_GETEXTATTR_DESCOFFSET, 1816 "vop_getextattr", 1817 0, 1818 vop_getextattr_vp_offsets, 1819 VDESC_NO_OFFSET, 1820 VOPARG_OFFSETOF(struct vop_getextattr_args, a_cred), 1821 VDESC_NO_OFFSET, 1822 NULL, 1823 }; 1824 int 1825 VOP_GETEXTATTR(struct vnode *vp, 1826 int attrnamespace, 1827 const char *name, 1828 struct uio *uio, 1829 size_t *size, 1830 kauth_cred_t cred) 1831 { 1832 int error; 1833 bool mpsafe; 1834 struct vop_getextattr_args a; 1835 #ifdef VNODE_LOCKDEBUG 1836 int islocked_vp; 1837 #endif 1838 a.a_desc = VDESC(vop_getextattr); 1839 a.a_vp = vp; 1840 #ifdef VNODE_LOCKDEBUG 1841 islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1842 if (islocked_vp != 1) 1843 panic("vop_getextattr: vp: locked %d, expected %d", islocked_vp, 1); 1844 #endif 1845 a.a_attrnamespace = attrnamespace; 1846 a.a_name = name; 1847 a.a_uio = uio; 1848 a.a_size = size; 1849 a.a_cred = cred; 1850 mpsafe = (vp->v_vflag & VV_MPSAFE); 1851 if (!mpsafe) { KERNEL_LOCK(1, curlwp); } 1852 error = (VCALL(vp, VOFFSET(vop_getextattr), &a)); 1853 if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); } 1854 return error; 1855 } 1856 1857 const int vop_listextattr_vp_offsets[] = { 1858 VOPARG_OFFSETOF(struct vop_listextattr_args,a_vp), 1859 VDESC_NO_OFFSET 1860 }; 1861 const struct vnodeop_desc vop_listextattr_desc = { 1862 VOP_LISTEXTATTR_DESCOFFSET, 1863 "vop_listextattr", 1864 0, 1865 vop_listextattr_vp_offsets, 1866 VDESC_NO_OFFSET, 1867 VOPARG_OFFSETOF(struct vop_listextattr_args, a_cred), 1868 VDESC_NO_OFFSET, 1869 NULL, 1870 }; 1871 int 1872 VOP_LISTEXTATTR(struct vnode *vp, 1873 int attrnamespace, 1874 struct uio *uio, 1875 size_t *size, 1876 kauth_cred_t cred) 1877 { 1878 int error; 1879 bool mpsafe; 1880 struct vop_listextattr_args a; 1881 #ifdef VNODE_LOCKDEBUG 1882 int islocked_vp; 1883 #endif 1884 a.a_desc = VDESC(vop_listextattr); 1885 a.a_vp = vp; 1886 #ifdef VNODE_LOCKDEBUG 1887 islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1888 if (islocked_vp != 1) 1889 panic("vop_listextattr: vp: locked %d, expected %d", islocked_vp, 1); 1890 #endif 1891 a.a_attrnamespace = attrnamespace; 1892 a.a_uio = uio; 1893 a.a_size = size; 1894 a.a_cred = cred; 1895 mpsafe = (vp->v_vflag & VV_MPSAFE); 1896 if (!mpsafe) { KERNEL_LOCK(1, curlwp); } 1897 error = (VCALL(vp, VOFFSET(vop_listextattr), &a)); 1898 if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); } 1899 return error; 1900 } 1901 1902 const int vop_openextattr_vp_offsets[] = { 1903 VOPARG_OFFSETOF(struct vop_openextattr_args,a_vp), 1904 VDESC_NO_OFFSET 1905 }; 1906 const struct vnodeop_desc vop_openextattr_desc = { 1907 VOP_OPENEXTATTR_DESCOFFSET, 1908 "vop_openextattr", 1909 0, 1910 vop_openextattr_vp_offsets, 1911 VDESC_NO_OFFSET, 1912 VOPARG_OFFSETOF(struct vop_openextattr_args, a_cred), 1913 VDESC_NO_OFFSET, 1914 NULL, 1915 }; 1916 int 1917 VOP_OPENEXTATTR(struct vnode *vp, 1918 kauth_cred_t cred) 1919 { 1920 int error; 1921 bool mpsafe; 1922 struct vop_openextattr_args a; 1923 #ifdef VNODE_LOCKDEBUG 1924 int islocked_vp; 1925 #endif 1926 a.a_desc = VDESC(vop_openextattr); 1927 a.a_vp = vp; 1928 #ifdef VNODE_LOCKDEBUG 1929 islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1930 if (islocked_vp != 1) 1931 panic("vop_openextattr: vp: locked %d, expected %d", islocked_vp, 1); 1932 #endif 1933 a.a_cred = cred; 1934 mpsafe = (vp->v_vflag & VV_MPSAFE); 1935 if (!mpsafe) { KERNEL_LOCK(1, curlwp); } 1936 error = (VCALL(vp, VOFFSET(vop_openextattr), &a)); 1937 if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); } 1938 return error; 1939 } 1940 1941 const int vop_deleteextattr_vp_offsets[] = { 1942 VOPARG_OFFSETOF(struct vop_deleteextattr_args,a_vp), 1943 VDESC_NO_OFFSET 1944 }; 1945 const struct vnodeop_desc vop_deleteextattr_desc = { 1946 VOP_DELETEEXTATTR_DESCOFFSET, 1947 "vop_deleteextattr", 1948 0, 1949 vop_deleteextattr_vp_offsets, 1950 VDESC_NO_OFFSET, 1951 VOPARG_OFFSETOF(struct vop_deleteextattr_args, a_cred), 1952 VDESC_NO_OFFSET, 1953 NULL, 1954 }; 1955 int 1956 VOP_DELETEEXTATTR(struct vnode *vp, 1957 int attrnamespace, 1958 const char *name, 1959 kauth_cred_t cred) 1960 { 1961 int error; 1962 bool mpsafe; 1963 struct vop_deleteextattr_args a; 1964 #ifdef VNODE_LOCKDEBUG 1965 int islocked_vp; 1966 #endif 1967 a.a_desc = VDESC(vop_deleteextattr); 1968 a.a_vp = vp; 1969 #ifdef VNODE_LOCKDEBUG 1970 islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1971 if (islocked_vp != 1) 1972 panic("vop_deleteextattr: vp: locked %d, expected %d", islocked_vp, 1); 1973 #endif 1974 a.a_attrnamespace = attrnamespace; 1975 a.a_name = name; 1976 a.a_cred = cred; 1977 mpsafe = (vp->v_vflag & VV_MPSAFE); 1978 if (!mpsafe) { KERNEL_LOCK(1, curlwp); } 1979 error = (VCALL(vp, VOFFSET(vop_deleteextattr), &a)); 1980 if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); } 1981 return error; 1982 } 1983 1984 const int vop_setextattr_vp_offsets[] = { 1985 VOPARG_OFFSETOF(struct vop_setextattr_args,a_vp), 1986 VDESC_NO_OFFSET 1987 }; 1988 const struct vnodeop_desc vop_setextattr_desc = { 1989 VOP_SETEXTATTR_DESCOFFSET, 1990 "vop_setextattr", 1991 0, 1992 vop_setextattr_vp_offsets, 1993 VDESC_NO_OFFSET, 1994 VOPARG_OFFSETOF(struct vop_setextattr_args, a_cred), 1995 VDESC_NO_OFFSET, 1996 NULL, 1997 }; 1998 int 1999 VOP_SETEXTATTR(struct vnode *vp, 2000 int attrnamespace, 2001 const char *name, 2002 struct uio *uio, 2003 kauth_cred_t cred) 2004 { 2005 int error; 2006 bool mpsafe; 2007 struct vop_setextattr_args a; 2008 #ifdef VNODE_LOCKDEBUG 2009 int islocked_vp; 2010 #endif 2011 a.a_desc = VDESC(vop_setextattr); 2012 a.a_vp = vp; 2013 #ifdef VNODE_LOCKDEBUG 2014 islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 2015 if (islocked_vp != 1) 2016 panic("vop_setextattr: vp: locked %d, expected %d", islocked_vp, 1); 2017 #endif 2018 a.a_attrnamespace = attrnamespace; 2019 a.a_name = name; 2020 a.a_uio = uio; 2021 a.a_cred = cred; 2022 mpsafe = (vp->v_vflag & VV_MPSAFE); 2023 if (!mpsafe) { KERNEL_LOCK(1, curlwp); } 2024 error = (VCALL(vp, VOFFSET(vop_setextattr), &a)); 2025 if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); } 2026 return error; 2027 } 2028 2029 /* End of special cases. */ 2030 2031 const struct vnodeop_desc * const vfs_op_descs[] = { 2032 &vop_default_desc, /* MUST BE FIRST */ 2033 &vop_bwrite_desc, /* XXX: SPECIAL CASE */ 2034 2035 &vop_lookup_desc, 2036 &vop_create_desc, 2037 &vop_mknod_desc, 2038 &vop_open_desc, 2039 &vop_close_desc, 2040 &vop_access_desc, 2041 &vop_getattr_desc, 2042 &vop_setattr_desc, 2043 &vop_read_desc, 2044 &vop_write_desc, 2045 &vop_ioctl_desc, 2046 &vop_fcntl_desc, 2047 &vop_poll_desc, 2048 &vop_kqfilter_desc, 2049 &vop_revoke_desc, 2050 &vop_mmap_desc, 2051 &vop_fsync_desc, 2052 &vop_seek_desc, 2053 &vop_remove_desc, 2054 &vop_link_desc, 2055 &vop_rename_desc, 2056 &vop_mkdir_desc, 2057 &vop_rmdir_desc, 2058 &vop_symlink_desc, 2059 &vop_readdir_desc, 2060 &vop_readlink_desc, 2061 &vop_abortop_desc, 2062 &vop_inactive_desc, 2063 &vop_reclaim_desc, 2064 &vop_lock_desc, 2065 &vop_unlock_desc, 2066 &vop_bmap_desc, 2067 &vop_strategy_desc, 2068 &vop_print_desc, 2069 &vop_islocked_desc, 2070 &vop_pathconf_desc, 2071 &vop_advlock_desc, 2072 &vop_whiteout_desc, 2073 &vop_getpages_desc, 2074 &vop_putpages_desc, 2075 &vop_closeextattr_desc, 2076 &vop_getextattr_desc, 2077 &vop_listextattr_desc, 2078 &vop_openextattr_desc, 2079 &vop_deleteextattr_desc, 2080 &vop_setextattr_desc, 2081 NULL 2082 }; 2083 2084
Indexes created Tue Sep 30 20:09:53 GMT 2025