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