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