vnode_if.c revision 1.53.4.6
1 /* $NetBSD: vnode_if.c,v 1.53.4.6 2007/12/07 17:33:26 yamt 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.55 2007/11/26 19:02:11 pooka Exp 9 * by the script: 10 * NetBSD: vnode_if.sh,v 1.47 2007/11/26 19:02:11 pooka 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.53.4.6 2007/12/07 17:33:26 yamt 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 { 1288 int error; 1289 bool mpsafe; 1290 struct vop_inactive_args a; 1291 #ifdef VNODE_LOCKDEBUG 1292 int islocked_vp; 1293 #endif 1294 a.a_desc = VDESC(vop_inactive); 1295 a.a_vp = vp; 1296 #ifdef VNODE_LOCKDEBUG 1297 islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1298 if (islocked_vp != 1) 1299 panic("vop_inactive: vp: locked %d, expected %d", islocked_vp, 1); 1300 #endif 1301 mpsafe = (vp->v_vflag & VV_MPSAFE); 1302 if (!mpsafe) { KERNEL_LOCK(1, curlwp); } 1303 error = (VCALL(vp, VOFFSET(vop_inactive), &a)); 1304 if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); } 1305 return error; 1306 } 1307 1308 const int vop_reclaim_vp_offsets[] = { 1309 VOPARG_OFFSETOF(struct vop_reclaim_args,a_vp), 1310 VDESC_NO_OFFSET 1311 }; 1312 const struct vnodeop_desc vop_reclaim_desc = { 1313 VOP_RECLAIM_DESCOFFSET, 1314 "vop_reclaim", 1315 0, 1316 vop_reclaim_vp_offsets, 1317 VDESC_NO_OFFSET, 1318 VDESC_NO_OFFSET, 1319 VDESC_NO_OFFSET, 1320 NULL, 1321 }; 1322 int 1323 VOP_RECLAIM(struct vnode *vp) 1324 { 1325 int error; 1326 bool mpsafe; 1327 struct vop_reclaim_args a; 1328 #ifdef VNODE_LOCKDEBUG 1329 int islocked_vp; 1330 #endif 1331 a.a_desc = VDESC(vop_reclaim); 1332 a.a_vp = vp; 1333 #ifdef VNODE_LOCKDEBUG 1334 islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0; 1335 if (islocked_vp != 0) 1336 panic("vop_reclaim: vp: locked %d, expected %d", islocked_vp, 0); 1337 #endif 1338 mpsafe = (vp->v_vflag & VV_MPSAFE); 1339 if (!mpsafe) { KERNEL_LOCK(1, curlwp); } 1340 error = (VCALL(vp, VOFFSET(vop_reclaim), &a)); 1341 if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); } 1342 return error; 1343 } 1344 1345 const int vop_lock_vp_offsets[] = { 1346 VOPARG_OFFSETOF(struct vop_lock_args,a_vp), 1347 VDESC_NO_OFFSET 1348 }; 1349 const struct vnodeop_desc vop_lock_desc = { 1350 VOP_LOCK_DESCOFFSET, 1351 "vop_lock", 1352 0, 1353 vop_lock_vp_offsets, 1354 VDESC_NO_OFFSET, 1355 VDESC_NO_OFFSET, 1356 VDESC_NO_OFFSET, 1357 NULL, 1358 }; 1359 int 1360 VOP_LOCK(struct vnode *vp, 1361 int flags) 1362 { 1363 int error; 1364 bool mpsafe; 1365 struct vop_lock_args a; 1366 #ifdef VNODE_LOCKDEBUG 1367 int islocked_vp; 1368 #endif 1369 a.a_desc = VDESC(vop_lock); 1370 a.a_vp = vp; 1371 #ifdef VNODE_LOCKDEBUG 1372 islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0; 1373 if (islocked_vp != 0) 1374 panic("vop_lock: vp: locked %d, expected %d", islocked_vp, 0); 1375 #endif 1376 a.a_flags = flags; 1377 mpsafe = (vp->v_vflag & VV_MPSAFE); 1378 if (!mpsafe) { KERNEL_LOCK(1, curlwp); } 1379 error = (VCALL(vp, VOFFSET(vop_lock), &a)); 1380 if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); } 1381 return error; 1382 } 1383 1384 const int vop_unlock_vp_offsets[] = { 1385 VOPARG_OFFSETOF(struct vop_unlock_args,a_vp), 1386 VDESC_NO_OFFSET 1387 }; 1388 const struct vnodeop_desc vop_unlock_desc = { 1389 VOP_UNLOCK_DESCOFFSET, 1390 "vop_unlock", 1391 0, 1392 vop_unlock_vp_offsets, 1393 VDESC_NO_OFFSET, 1394 VDESC_NO_OFFSET, 1395 VDESC_NO_OFFSET, 1396 NULL, 1397 }; 1398 int 1399 VOP_UNLOCK(struct vnode *vp, 1400 int flags) 1401 { 1402 int error; 1403 bool mpsafe; 1404 struct vop_unlock_args a; 1405 #ifdef VNODE_LOCKDEBUG 1406 int islocked_vp; 1407 #endif 1408 a.a_desc = VDESC(vop_unlock); 1409 a.a_vp = vp; 1410 #ifdef VNODE_LOCKDEBUG 1411 islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1412 if (islocked_vp != 1) 1413 panic("vop_unlock: vp: locked %d, expected %d", islocked_vp, 1); 1414 #endif 1415 a.a_flags = flags; 1416 mpsafe = (vp->v_vflag & VV_MPSAFE); 1417 if (!mpsafe) { KERNEL_LOCK(1, curlwp); } 1418 error = (VCALL(vp, VOFFSET(vop_unlock), &a)); 1419 if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); } 1420 return error; 1421 } 1422 1423 const int vop_bmap_vp_offsets[] = { 1424 VOPARG_OFFSETOF(struct vop_bmap_args,a_vp), 1425 VDESC_NO_OFFSET 1426 }; 1427 const struct vnodeop_desc vop_bmap_desc = { 1428 VOP_BMAP_DESCOFFSET, 1429 "vop_bmap", 1430 0, 1431 vop_bmap_vp_offsets, 1432 VOPARG_OFFSETOF(struct vop_bmap_args, a_vpp), 1433 VDESC_NO_OFFSET, 1434 VDESC_NO_OFFSET, 1435 NULL, 1436 }; 1437 int 1438 VOP_BMAP(struct vnode *vp, 1439 daddr_t bn, 1440 struct vnode **vpp, 1441 daddr_t *bnp, 1442 int *runp) 1443 { 1444 int error; 1445 bool mpsafe; 1446 struct vop_bmap_args a; 1447 #ifdef VNODE_LOCKDEBUG 1448 #endif 1449 a.a_desc = VDESC(vop_bmap); 1450 a.a_vp = vp; 1451 a.a_bn = bn; 1452 a.a_vpp = vpp; 1453 a.a_bnp = bnp; 1454 a.a_runp = runp; 1455 mpsafe = (vp->v_vflag & VV_MPSAFE); 1456 if (!mpsafe) { KERNEL_LOCK(1, curlwp); } 1457 error = (VCALL(vp, VOFFSET(vop_bmap), &a)); 1458 if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); } 1459 return error; 1460 } 1461 1462 const int vop_strategy_vp_offsets[] = { 1463 VOPARG_OFFSETOF(struct vop_strategy_args,a_vp), 1464 VDESC_NO_OFFSET 1465 }; 1466 const struct vnodeop_desc vop_strategy_desc = { 1467 VOP_STRATEGY_DESCOFFSET, 1468 "vop_strategy", 1469 0, 1470 vop_strategy_vp_offsets, 1471 VDESC_NO_OFFSET, 1472 VDESC_NO_OFFSET, 1473 VDESC_NO_OFFSET, 1474 NULL, 1475 }; 1476 int 1477 VOP_STRATEGY(struct vnode *vp, 1478 struct buf *bp) 1479 { 1480 int error; 1481 bool mpsafe; 1482 struct vop_strategy_args a; 1483 #ifdef VNODE_LOCKDEBUG 1484 #endif 1485 a.a_desc = VDESC(vop_strategy); 1486 a.a_vp = vp; 1487 a.a_bp = bp; 1488 mpsafe = (vp->v_vflag & VV_MPSAFE); 1489 if (!mpsafe) { KERNEL_LOCK(1, curlwp); } 1490 error = (VCALL(vp, VOFFSET(vop_strategy), &a)); 1491 if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); } 1492 return error; 1493 } 1494 1495 const int vop_print_vp_offsets[] = { 1496 VOPARG_OFFSETOF(struct vop_print_args,a_vp), 1497 VDESC_NO_OFFSET 1498 }; 1499 const struct vnodeop_desc vop_print_desc = { 1500 VOP_PRINT_DESCOFFSET, 1501 "vop_print", 1502 0, 1503 vop_print_vp_offsets, 1504 VDESC_NO_OFFSET, 1505 VDESC_NO_OFFSET, 1506 VDESC_NO_OFFSET, 1507 NULL, 1508 }; 1509 int 1510 VOP_PRINT(struct vnode *vp) 1511 { 1512 int error; 1513 bool mpsafe; 1514 struct vop_print_args a; 1515 #ifdef VNODE_LOCKDEBUG 1516 #endif 1517 a.a_desc = VDESC(vop_print); 1518 a.a_vp = vp; 1519 mpsafe = (vp->v_vflag & VV_MPSAFE); 1520 if (!mpsafe) { KERNEL_LOCK(1, curlwp); } 1521 error = (VCALL(vp, VOFFSET(vop_print), &a)); 1522 if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); } 1523 return error; 1524 } 1525 1526 const int vop_islocked_vp_offsets[] = { 1527 VOPARG_OFFSETOF(struct vop_islocked_args,a_vp), 1528 VDESC_NO_OFFSET 1529 }; 1530 const struct vnodeop_desc vop_islocked_desc = { 1531 VOP_ISLOCKED_DESCOFFSET, 1532 "vop_islocked", 1533 0, 1534 vop_islocked_vp_offsets, 1535 VDESC_NO_OFFSET, 1536 VDESC_NO_OFFSET, 1537 VDESC_NO_OFFSET, 1538 NULL, 1539 }; 1540 int 1541 VOP_ISLOCKED(struct vnode *vp) 1542 { 1543 int error; 1544 bool mpsafe; 1545 struct vop_islocked_args a; 1546 #ifdef VNODE_LOCKDEBUG 1547 #endif 1548 a.a_desc = VDESC(vop_islocked); 1549 a.a_vp = vp; 1550 mpsafe = (vp->v_vflag & VV_MPSAFE); 1551 if (!mpsafe) { KERNEL_LOCK(1, curlwp); } 1552 error = (VCALL(vp, VOFFSET(vop_islocked), &a)); 1553 if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); } 1554 return error; 1555 } 1556 1557 const int vop_pathconf_vp_offsets[] = { 1558 VOPARG_OFFSETOF(struct vop_pathconf_args,a_vp), 1559 VDESC_NO_OFFSET 1560 }; 1561 const struct vnodeop_desc vop_pathconf_desc = { 1562 VOP_PATHCONF_DESCOFFSET, 1563 "vop_pathconf", 1564 0, 1565 vop_pathconf_vp_offsets, 1566 VDESC_NO_OFFSET, 1567 VDESC_NO_OFFSET, 1568 VDESC_NO_OFFSET, 1569 NULL, 1570 }; 1571 int 1572 VOP_PATHCONF(struct vnode *vp, 1573 int name, 1574 register_t *retval) 1575 { 1576 int error; 1577 bool mpsafe; 1578 struct vop_pathconf_args a; 1579 #ifdef VNODE_LOCKDEBUG 1580 int islocked_vp; 1581 #endif 1582 a.a_desc = VDESC(vop_pathconf); 1583 a.a_vp = vp; 1584 #ifdef VNODE_LOCKDEBUG 1585 islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1586 if (islocked_vp != 1) 1587 panic("vop_pathconf: vp: locked %d, expected %d", islocked_vp, 1); 1588 #endif 1589 a.a_name = name; 1590 a.a_retval = retval; 1591 mpsafe = (vp->v_vflag & VV_MPSAFE); 1592 if (!mpsafe) { KERNEL_LOCK(1, curlwp); } 1593 error = (VCALL(vp, VOFFSET(vop_pathconf), &a)); 1594 if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); } 1595 return error; 1596 } 1597 1598 const int vop_advlock_vp_offsets[] = { 1599 VOPARG_OFFSETOF(struct vop_advlock_args,a_vp), 1600 VDESC_NO_OFFSET 1601 }; 1602 const struct vnodeop_desc vop_advlock_desc = { 1603 VOP_ADVLOCK_DESCOFFSET, 1604 "vop_advlock", 1605 0, 1606 vop_advlock_vp_offsets, 1607 VDESC_NO_OFFSET, 1608 VDESC_NO_OFFSET, 1609 VDESC_NO_OFFSET, 1610 NULL, 1611 }; 1612 int 1613 VOP_ADVLOCK(struct vnode *vp, 1614 void *id, 1615 int op, 1616 struct flock *fl, 1617 int flags) 1618 { 1619 int error; 1620 bool mpsafe; 1621 struct vop_advlock_args a; 1622 #ifdef VNODE_LOCKDEBUG 1623 int islocked_vp; 1624 #endif 1625 a.a_desc = VDESC(vop_advlock); 1626 a.a_vp = vp; 1627 #ifdef VNODE_LOCKDEBUG 1628 islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0; 1629 if (islocked_vp != 0) 1630 panic("vop_advlock: vp: locked %d, expected %d", islocked_vp, 0); 1631 #endif 1632 a.a_id = id; 1633 a.a_op = op; 1634 a.a_fl = fl; 1635 a.a_flags = flags; 1636 mpsafe = (vp->v_vflag & VV_MPSAFE); 1637 if (!mpsafe) { KERNEL_LOCK(1, curlwp); } 1638 error = (VCALL(vp, VOFFSET(vop_advlock), &a)); 1639 if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); } 1640 return error; 1641 } 1642 1643 const int vop_lease_vp_offsets[] = { 1644 VOPARG_OFFSETOF(struct vop_lease_args,a_vp), 1645 VDESC_NO_OFFSET 1646 }; 1647 const struct vnodeop_desc vop_lease_desc = { 1648 VOP_LEASE_DESCOFFSET, 1649 "vop_lease", 1650 0, 1651 vop_lease_vp_offsets, 1652 VDESC_NO_OFFSET, 1653 VOPARG_OFFSETOF(struct vop_lease_args, a_cred), 1654 VDESC_NO_OFFSET, 1655 NULL, 1656 }; 1657 int 1658 VOP_LEASE(struct vnode *vp, 1659 kauth_cred_t cred, 1660 int flag) 1661 { 1662 int error; 1663 bool mpsafe; 1664 struct vop_lease_args a; 1665 #ifdef VNODE_LOCKDEBUG 1666 #endif 1667 a.a_desc = VDESC(vop_lease); 1668 a.a_vp = vp; 1669 a.a_cred = cred; 1670 a.a_flag = flag; 1671 mpsafe = (vp->v_vflag & VV_MPSAFE); 1672 if (!mpsafe) { KERNEL_LOCK(1, curlwp); } 1673 error = (VCALL(vp, VOFFSET(vop_lease), &a)); 1674 if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); } 1675 return error; 1676 } 1677 1678 const int vop_whiteout_vp_offsets[] = { 1679 VOPARG_OFFSETOF(struct vop_whiteout_args,a_dvp), 1680 VDESC_NO_OFFSET 1681 }; 1682 const struct vnodeop_desc vop_whiteout_desc = { 1683 VOP_WHITEOUT_DESCOFFSET, 1684 "vop_whiteout", 1685 0, 1686 vop_whiteout_vp_offsets, 1687 VDESC_NO_OFFSET, 1688 VDESC_NO_OFFSET, 1689 VOPARG_OFFSETOF(struct vop_whiteout_args, a_cnp), 1690 NULL, 1691 }; 1692 int 1693 VOP_WHITEOUT(struct vnode *dvp, 1694 struct componentname *cnp, 1695 int flags) 1696 { 1697 int error; 1698 bool mpsafe; 1699 struct vop_whiteout_args a; 1700 #ifdef VNODE_LOCKDEBUG 1701 int islocked_dvp; 1702 #endif 1703 a.a_desc = VDESC(vop_whiteout); 1704 a.a_dvp = dvp; 1705 #ifdef VNODE_LOCKDEBUG 1706 islocked_dvp = (dvp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1; 1707 if (islocked_dvp != 1) 1708 panic("vop_whiteout: dvp: locked %d, expected %d", islocked_dvp, 1); 1709 #endif 1710 a.a_cnp = cnp; 1711 a.a_flags = flags; 1712 mpsafe = (dvp->v_vflag & VV_MPSAFE); 1713 if (!mpsafe) { KERNEL_LOCK(1, curlwp); } 1714 error = (VCALL(dvp, VOFFSET(vop_whiteout), &a)); 1715 if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); } 1716 return error; 1717 } 1718 1719 const int vop_getpages_vp_offsets[] = { 1720 VOPARG_OFFSETOF(struct vop_getpages_args,a_vp), 1721 VDESC_NO_OFFSET 1722 }; 1723 const struct vnodeop_desc vop_getpages_desc = { 1724 VOP_GETPAGES_DESCOFFSET, 1725 "vop_getpages", 1726 0, 1727 vop_getpages_vp_offsets, 1728 VDESC_NO_OFFSET, 1729 VDESC_NO_OFFSET, 1730 VDESC_NO_OFFSET, 1731 NULL, 1732 }; 1733 int 1734 VOP_GETPAGES(struct vnode *vp, 1735 voff_t offset, 1736 struct vm_page **m, 1737 int *count, 1738 int centeridx, 1739 vm_prot_t access_type, 1740 int advice, 1741 int flags) 1742 { 1743 int error; 1744 bool mpsafe; 1745 struct vop_getpages_args a; 1746 #ifdef VNODE_LOCKDEBUG 1747 #endif 1748 a.a_desc = VDESC(vop_getpages); 1749 a.a_vp = vp; 1750 a.a_offset = offset; 1751 a.a_m = m; 1752 a.a_count = count; 1753 a.a_centeridx = centeridx; 1754 a.a_access_type = access_type; 1755 a.a_advice = advice; 1756 a.a_flags = flags; 1757 mpsafe = (vp->v_vflag & VV_MPSAFE); 1758 if (!mpsafe) { KERNEL_LOCK(1, curlwp); } 1759 error = (VCALL(vp, VOFFSET(vop_getpages), &a)); 1760 if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); } 1761 return error; 1762 } 1763 1764 const int vop_putpages_vp_offsets[] = { 1765 VOPARG_OFFSETOF(struct vop_putpages_args,a_vp), 1766 VDESC_NO_OFFSET 1767 }; 1768 const struct vnodeop_desc vop_putpages_desc = { 1769 VOP_PUTPAGES_DESCOFFSET, 1770 "vop_putpages", 1771 0, 1772 vop_putpages_vp_offsets, 1773 VDESC_NO_OFFSET, 1774 VDESC_NO_OFFSET, 1775 VDESC_NO_OFFSET, 1776 NULL, 1777 }; 1778 int 1779 VOP_PUTPAGES(struct vnode *vp, 1780 voff_t offlo, 1781 voff_t offhi, 1782 int flags) 1783 { 1784 int error; 1785 bool mpsafe; 1786 struct vop_putpages_args a; 1787 #ifdef VNODE_LOCKDEBUG 1788 #endif 1789 a.a_desc = VDESC(vop_putpages); 1790 a.a_vp = vp; 1791 a.a_offlo = offlo; 1792 a.a_offhi = offhi; 1793 a.a_flags = flags; 1794 mpsafe = (vp->v_vflag & VV_MPSAFE); 1795 if (!mpsafe) { KERNEL_LOCK(1, curlwp); } 1796 error = (VCALL(vp, VOFFSET(vop_putpages), &a)); 1797 if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); } 1798 return error; 1799 } 1800 1801 const int vop_closeextattr_vp_offsets[] = { 1802 VOPARG_OFFSETOF(struct vop_closeextattr_args,a_vp), 1803 VDESC_NO_OFFSET 1804 }; 1805 const struct vnodeop_desc vop_closeextattr_desc = { 1806 VOP_CLOSEEXTATTR_DESCOFFSET, 1807 "vop_closeextattr", 1808 0, 1809 vop_closeextattr_vp_offsets, 1810 VDESC_NO_OFFSET, 1811 VOPARG_OFFSETOF(struct vop_closeextattr_args, a_cred), 1812 VDESC_NO_OFFSET, 1813 NULL, 1814 }; 1815 int 1816 VOP_CLOSEEXTATTR(struct vnode *vp, 1817 int commit, 1818 kauth_cred_t cred) 1819 { 1820 int error; 1821 bool mpsafe; 1822 struct vop_closeextattr_args a; 1823 #ifdef VNODE_LOCKDEBUG 1824 int islocked_vp; 1825 #endif 1826 a.a_desc = VDESC(vop_closeextattr); 1827 a.a_vp = vp; 1828 #ifdef VNODE_LOCKDEBUG 1829 islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1830 if (islocked_vp != 1) 1831 panic("vop_closeextattr: vp: locked %d, expected %d", islocked_vp, 1); 1832 #endif 1833 a.a_commit = commit; 1834 a.a_cred = cred; 1835 mpsafe = (vp->v_vflag & VV_MPSAFE); 1836 if (!mpsafe) { KERNEL_LOCK(1, curlwp); } 1837 error = (VCALL(vp, VOFFSET(vop_closeextattr), &a)); 1838 if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); } 1839 return error; 1840 } 1841 1842 const int vop_getextattr_vp_offsets[] = { 1843 VOPARG_OFFSETOF(struct vop_getextattr_args,a_vp), 1844 VDESC_NO_OFFSET 1845 }; 1846 const struct vnodeop_desc vop_getextattr_desc = { 1847 VOP_GETEXTATTR_DESCOFFSET, 1848 "vop_getextattr", 1849 0, 1850 vop_getextattr_vp_offsets, 1851 VDESC_NO_OFFSET, 1852 VOPARG_OFFSETOF(struct vop_getextattr_args, a_cred), 1853 VDESC_NO_OFFSET, 1854 NULL, 1855 }; 1856 int 1857 VOP_GETEXTATTR(struct vnode *vp, 1858 int attrnamespace, 1859 const char *name, 1860 struct uio *uio, 1861 size_t *size, 1862 kauth_cred_t cred) 1863 { 1864 int error; 1865 bool mpsafe; 1866 struct vop_getextattr_args a; 1867 #ifdef VNODE_LOCKDEBUG 1868 int islocked_vp; 1869 #endif 1870 a.a_desc = VDESC(vop_getextattr); 1871 a.a_vp = vp; 1872 #ifdef VNODE_LOCKDEBUG 1873 islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1874 if (islocked_vp != 1) 1875 panic("vop_getextattr: vp: locked %d, expected %d", islocked_vp, 1); 1876 #endif 1877 a.a_attrnamespace = attrnamespace; 1878 a.a_name = name; 1879 a.a_uio = uio; 1880 a.a_size = size; 1881 a.a_cred = cred; 1882 mpsafe = (vp->v_vflag & VV_MPSAFE); 1883 if (!mpsafe) { KERNEL_LOCK(1, curlwp); } 1884 error = (VCALL(vp, VOFFSET(vop_getextattr), &a)); 1885 if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); } 1886 return error; 1887 } 1888 1889 const int vop_listextattr_vp_offsets[] = { 1890 VOPARG_OFFSETOF(struct vop_listextattr_args,a_vp), 1891 VDESC_NO_OFFSET 1892 }; 1893 const struct vnodeop_desc vop_listextattr_desc = { 1894 VOP_LISTEXTATTR_DESCOFFSET, 1895 "vop_listextattr", 1896 0, 1897 vop_listextattr_vp_offsets, 1898 VDESC_NO_OFFSET, 1899 VOPARG_OFFSETOF(struct vop_listextattr_args, a_cred), 1900 VDESC_NO_OFFSET, 1901 NULL, 1902 }; 1903 int 1904 VOP_LISTEXTATTR(struct vnode *vp, 1905 int attrnamespace, 1906 struct uio *uio, 1907 size_t *size, 1908 kauth_cred_t cred) 1909 { 1910 int error; 1911 bool mpsafe; 1912 struct vop_listextattr_args a; 1913 #ifdef VNODE_LOCKDEBUG 1914 int islocked_vp; 1915 #endif 1916 a.a_desc = VDESC(vop_listextattr); 1917 a.a_vp = vp; 1918 #ifdef VNODE_LOCKDEBUG 1919 islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1920 if (islocked_vp != 1) 1921 panic("vop_listextattr: vp: locked %d, expected %d", islocked_vp, 1); 1922 #endif 1923 a.a_attrnamespace = attrnamespace; 1924 a.a_uio = uio; 1925 a.a_size = size; 1926 a.a_cred = cred; 1927 mpsafe = (vp->v_vflag & VV_MPSAFE); 1928 if (!mpsafe) { KERNEL_LOCK(1, curlwp); } 1929 error = (VCALL(vp, VOFFSET(vop_listextattr), &a)); 1930 if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); } 1931 return error; 1932 } 1933 1934 const int vop_openextattr_vp_offsets[] = { 1935 VOPARG_OFFSETOF(struct vop_openextattr_args,a_vp), 1936 VDESC_NO_OFFSET 1937 }; 1938 const struct vnodeop_desc vop_openextattr_desc = { 1939 VOP_OPENEXTATTR_DESCOFFSET, 1940 "vop_openextattr", 1941 0, 1942 vop_openextattr_vp_offsets, 1943 VDESC_NO_OFFSET, 1944 VOPARG_OFFSETOF(struct vop_openextattr_args, a_cred), 1945 VDESC_NO_OFFSET, 1946 NULL, 1947 }; 1948 int 1949 VOP_OPENEXTATTR(struct vnode *vp, 1950 kauth_cred_t cred) 1951 { 1952 int error; 1953 bool mpsafe; 1954 struct vop_openextattr_args a; 1955 #ifdef VNODE_LOCKDEBUG 1956 int islocked_vp; 1957 #endif 1958 a.a_desc = VDESC(vop_openextattr); 1959 a.a_vp = vp; 1960 #ifdef VNODE_LOCKDEBUG 1961 islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 1962 if (islocked_vp != 1) 1963 panic("vop_openextattr: vp: locked %d, expected %d", islocked_vp, 1); 1964 #endif 1965 a.a_cred = cred; 1966 mpsafe = (vp->v_vflag & VV_MPSAFE); 1967 if (!mpsafe) { KERNEL_LOCK(1, curlwp); } 1968 error = (VCALL(vp, VOFFSET(vop_openextattr), &a)); 1969 if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); } 1970 return error; 1971 } 1972 1973 const int vop_deleteextattr_vp_offsets[] = { 1974 VOPARG_OFFSETOF(struct vop_deleteextattr_args,a_vp), 1975 VDESC_NO_OFFSET 1976 }; 1977 const struct vnodeop_desc vop_deleteextattr_desc = { 1978 VOP_DELETEEXTATTR_DESCOFFSET, 1979 "vop_deleteextattr", 1980 0, 1981 vop_deleteextattr_vp_offsets, 1982 VDESC_NO_OFFSET, 1983 VOPARG_OFFSETOF(struct vop_deleteextattr_args, a_cred), 1984 VDESC_NO_OFFSET, 1985 NULL, 1986 }; 1987 int 1988 VOP_DELETEEXTATTR(struct vnode *vp, 1989 int attrnamespace, 1990 const char *name, 1991 kauth_cred_t cred) 1992 { 1993 int error; 1994 bool mpsafe; 1995 struct vop_deleteextattr_args a; 1996 #ifdef VNODE_LOCKDEBUG 1997 int islocked_vp; 1998 #endif 1999 a.a_desc = VDESC(vop_deleteextattr); 2000 a.a_vp = vp; 2001 #ifdef VNODE_LOCKDEBUG 2002 islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 2003 if (islocked_vp != 1) 2004 panic("vop_deleteextattr: vp: locked %d, expected %d", islocked_vp, 1); 2005 #endif 2006 a.a_attrnamespace = attrnamespace; 2007 a.a_name = name; 2008 a.a_cred = cred; 2009 mpsafe = (vp->v_vflag & VV_MPSAFE); 2010 if (!mpsafe) { KERNEL_LOCK(1, curlwp); } 2011 error = (VCALL(vp, VOFFSET(vop_deleteextattr), &a)); 2012 if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); } 2013 return error; 2014 } 2015 2016 const int vop_setextattr_vp_offsets[] = { 2017 VOPARG_OFFSETOF(struct vop_setextattr_args,a_vp), 2018 VDESC_NO_OFFSET 2019 }; 2020 const struct vnodeop_desc vop_setextattr_desc = { 2021 VOP_SETEXTATTR_DESCOFFSET, 2022 "vop_setextattr", 2023 0, 2024 vop_setextattr_vp_offsets, 2025 VDESC_NO_OFFSET, 2026 VOPARG_OFFSETOF(struct vop_setextattr_args, a_cred), 2027 VDESC_NO_OFFSET, 2028 NULL, 2029 }; 2030 int 2031 VOP_SETEXTATTR(struct vnode *vp, 2032 int attrnamespace, 2033 const char *name, 2034 struct uio *uio, 2035 kauth_cred_t cred) 2036 { 2037 int error; 2038 bool mpsafe; 2039 struct vop_setextattr_args a; 2040 #ifdef VNODE_LOCKDEBUG 2041 int islocked_vp; 2042 #endif 2043 a.a_desc = VDESC(vop_setextattr); 2044 a.a_vp = vp; 2045 #ifdef VNODE_LOCKDEBUG 2046 islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1; 2047 if (islocked_vp != 1) 2048 panic("vop_setextattr: vp: locked %d, expected %d", islocked_vp, 1); 2049 #endif 2050 a.a_attrnamespace = attrnamespace; 2051 a.a_name = name; 2052 a.a_uio = uio; 2053 a.a_cred = cred; 2054 mpsafe = (vp->v_vflag & VV_MPSAFE); 2055 if (!mpsafe) { KERNEL_LOCK(1, curlwp); } 2056 error = (VCALL(vp, VOFFSET(vop_setextattr), &a)); 2057 if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); } 2058 return error; 2059 } 2060 2061 /* End of special cases. */ 2062 2063 const struct vnodeop_desc * const vfs_op_descs[] = { 2064 &vop_default_desc, /* MUST BE FIRST */ 2065 &vop_bwrite_desc, /* XXX: SPECIAL CASE */ 2066 2067 &vop_lookup_desc, 2068 &vop_create_desc, 2069 &vop_mknod_desc, 2070 &vop_open_desc, 2071 &vop_close_desc, 2072 &vop_access_desc, 2073 &vop_getattr_desc, 2074 &vop_setattr_desc, 2075 &vop_read_desc, 2076 &vop_write_desc, 2077 &vop_ioctl_desc, 2078 &vop_fcntl_desc, 2079 &vop_poll_desc, 2080 &vop_kqfilter_desc, 2081 &vop_revoke_desc, 2082 &vop_mmap_desc, 2083 &vop_fsync_desc, 2084 &vop_seek_desc, 2085 &vop_remove_desc, 2086 &vop_link_desc, 2087 &vop_rename_desc, 2088 &vop_mkdir_desc, 2089 &vop_rmdir_desc, 2090 &vop_symlink_desc, 2091 &vop_readdir_desc, 2092 &vop_readlink_desc, 2093 &vop_abortop_desc, 2094 &vop_inactive_desc, 2095 &vop_reclaim_desc, 2096 &vop_lock_desc, 2097 &vop_unlock_desc, 2098 &vop_bmap_desc, 2099 &vop_strategy_desc, 2100 &vop_print_desc, 2101 &vop_islocked_desc, 2102 &vop_pathconf_desc, 2103 &vop_advlock_desc, 2104 &vop_lease_desc, 2105 &vop_whiteout_desc, 2106 &vop_getpages_desc, 2107 &vop_putpages_desc, 2108 &vop_closeextattr_desc, 2109 &vop_getextattr_desc, 2110 &vop_listextattr_desc, 2111 &vop_openextattr_desc, 2112 &vop_deleteextattr_desc, 2113 &vop_setextattr_desc, 2114 NULL 2115 }; 2116 2117
Indexes created Tue Sep 30 20:09:53 GMT 2025