Annotation of src/sys/rump/librump/rumpvfs/rumpvnode_if.c, Revision 1.1
1.1 ! pooka 1: /* $NetBSD: rumpvnode_if.c,v 1.2 2008/11/17 08:59:33 pooka 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: rumpvnode_if.c,v 1.2 2008/11/17 08:59:33 pooka 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: #include <rump/rumpvnode_if.h>
! 54:
! 55: const struct vnodeop_desc rump_vop_default_desc = {
! 56: 0,
! 57: "default",
! 58: 0,
! 59: NULL,
! 60: VDESC_NO_OFFSET,
! 61: VDESC_NO_OFFSET,
! 62: VDESC_NO_OFFSET,
! 63: NULL,
! 64: };
! 65:
! 66:
! 67: /* Special cases: */
! 68:
! 69: const int rump_vop_bwrite_vp_offsets[] = {
! 70: VDESC_NO_OFFSET
! 71: };
! 72: const struct vnodeop_desc rump_vop_bwrite_desc = {
! 73: RUMP_VOP_BWRITE_DESCOFFSET,
! 74: "rump_vop_bwrite",
! 75: 0,
! 76: rump_vop_bwrite_vp_offsets,
! 77: VDESC_NO_OFFSET,
! 78: VDESC_NO_OFFSET,
! 79: VDESC_NO_OFFSET,
! 80: NULL,
! 81: };
! 82: int
! 83: RUMP_VOP_BWRITE(struct buf *bp)
! 84: {
! 85: int error;
! 86: bool mpsafe;
! 87: struct rump_vop_bwrite_args a;
! 88: #ifdef VNODE_LOCKDEBUG
! 89: #endif
! 90: a.a_desc = VDESC(rump_vop_bwrite);
! 91: a.a_bp = bp;
! 92: mpsafe = (bp->b_vp->v_vflag & VV_MPSAFE);
! 93: if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
! 94: error = (VCALL(bp->b_vp, VOFFSET(rump_vop_bwrite), &a));
! 95: if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
! 96: return error;
! 97: }
! 98:
! 99: /* End of special cases */
! 100:
! 101: const int rump_vop_lookup_vp_offsets[] = {
! 102: VOPARG_OFFSETOF(struct rump_vop_lookup_args,a_dvp),
! 103: VDESC_NO_OFFSET
! 104: };
! 105: const struct vnodeop_desc rump_vop_lookup_desc = {
! 106: RUMP_VOP_LOOKUP_DESCOFFSET,
! 107: "rump_vop_lookup",
! 108: 0,
! 109: rump_vop_lookup_vp_offsets,
! 110: VOPARG_OFFSETOF(struct rump_vop_lookup_args, a_vpp),
! 111: VDESC_NO_OFFSET,
! 112: VOPARG_OFFSETOF(struct rump_vop_lookup_args, a_cnp),
! 113: NULL,
! 114: };
! 115: int
! 116: RUMP_VOP_LOOKUP(struct vnode *dvp,
! 117: struct vnode **vpp,
! 118: struct componentname *cnp)
! 119: {
! 120: int error;
! 121: bool mpsafe;
! 122: struct rump_vop_lookup_args a;
! 123: #ifdef VNODE_LOCKDEBUG
! 124: #endif
! 125: a.a_desc = VDESC(rump_vop_lookup);
! 126: a.a_dvp = dvp;
! 127: a.a_vpp = vpp;
! 128: a.a_cnp = cnp;
! 129: mpsafe = (dvp->v_vflag & VV_MPSAFE);
! 130: if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
! 131: error = (VCALL(dvp, VOFFSET(rump_vop_lookup), &a));
! 132: if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
! 133: #ifdef DIAGNOSTIC
! 134: if (error == 0)
! 135: KASSERT((*vpp)->v_size != VSIZENOTSET
! 136: && (*vpp)->v_writesize != VSIZENOTSET);
! 137: #endif /* DIAGNOSTIC */
! 138: return error;
! 139: }
! 140:
! 141: const int rump_vop_create_vp_offsets[] = {
! 142: VOPARG_OFFSETOF(struct rump_vop_create_args,a_dvp),
! 143: VDESC_NO_OFFSET
! 144: };
! 145: const struct vnodeop_desc rump_vop_create_desc = {
! 146: RUMP_VOP_CREATE_DESCOFFSET,
! 147: "rump_vop_create",
! 148: 0 | VDESC_VP0_WILLPUT,
! 149: rump_vop_create_vp_offsets,
! 150: VOPARG_OFFSETOF(struct rump_vop_create_args, a_vpp),
! 151: VDESC_NO_OFFSET,
! 152: VOPARG_OFFSETOF(struct rump_vop_create_args, a_cnp),
! 153: NULL,
! 154: };
! 155: int
! 156: RUMP_VOP_CREATE(struct vnode *dvp,
! 157: struct vnode **vpp,
! 158: struct componentname *cnp,
! 159: struct vattr *vap)
! 160: {
! 161: int error;
! 162: bool mpsafe;
! 163: struct rump_vop_create_args a;
! 164: #ifdef VNODE_LOCKDEBUG
! 165: int islocked_dvp;
! 166: #endif
! 167: a.a_desc = VDESC(rump_vop_create);
! 168: a.a_dvp = dvp;
! 169: #ifdef VNODE_LOCKDEBUG
! 170: islocked_dvp = (dvp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1;
! 171: if (islocked_dvp != 1)
! 172: panic("rump_vop_create: dvp: locked %d, expected %d", islocked_dvp, 1);
! 173: #endif
! 174: a.a_vpp = vpp;
! 175: a.a_cnp = cnp;
! 176: a.a_vap = vap;
! 177: mpsafe = (dvp->v_vflag & VV_MPSAFE);
! 178: if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
! 179: error = (VCALL(dvp, VOFFSET(rump_vop_create), &a));
! 180: if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
! 181: #ifdef DIAGNOSTIC
! 182: if (error == 0)
! 183: KASSERT((*vpp)->v_size != VSIZENOTSET
! 184: && (*vpp)->v_writesize != VSIZENOTSET);
! 185: #endif /* DIAGNOSTIC */
! 186: return error;
! 187: }
! 188:
! 189: const int rump_vop_mknod_vp_offsets[] = {
! 190: VOPARG_OFFSETOF(struct rump_vop_mknod_args,a_dvp),
! 191: VDESC_NO_OFFSET
! 192: };
! 193: const struct vnodeop_desc rump_vop_mknod_desc = {
! 194: RUMP_VOP_MKNOD_DESCOFFSET,
! 195: "rump_vop_mknod",
! 196: 0 | VDESC_VP0_WILLPUT,
! 197: rump_vop_mknod_vp_offsets,
! 198: VOPARG_OFFSETOF(struct rump_vop_mknod_args, a_vpp),
! 199: VDESC_NO_OFFSET,
! 200: VOPARG_OFFSETOF(struct rump_vop_mknod_args, a_cnp),
! 201: NULL,
! 202: };
! 203: int
! 204: RUMP_VOP_MKNOD(struct vnode *dvp,
! 205: struct vnode **vpp,
! 206: struct componentname *cnp,
! 207: struct vattr *vap)
! 208: {
! 209: int error;
! 210: bool mpsafe;
! 211: struct rump_vop_mknod_args a;
! 212: #ifdef VNODE_LOCKDEBUG
! 213: int islocked_dvp;
! 214: #endif
! 215: a.a_desc = VDESC(rump_vop_mknod);
! 216: a.a_dvp = dvp;
! 217: #ifdef VNODE_LOCKDEBUG
! 218: islocked_dvp = (dvp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1;
! 219: if (islocked_dvp != 1)
! 220: panic("rump_vop_mknod: dvp: locked %d, expected %d", islocked_dvp, 1);
! 221: #endif
! 222: a.a_vpp = vpp;
! 223: a.a_cnp = cnp;
! 224: a.a_vap = vap;
! 225: mpsafe = (dvp->v_vflag & VV_MPSAFE);
! 226: if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
! 227: error = (VCALL(dvp, VOFFSET(rump_vop_mknod), &a));
! 228: if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
! 229: #ifdef DIAGNOSTIC
! 230: if (error == 0)
! 231: KASSERT((*vpp)->v_size != VSIZENOTSET
! 232: && (*vpp)->v_writesize != VSIZENOTSET);
! 233: #endif /* DIAGNOSTIC */
! 234: return error;
! 235: }
! 236:
! 237: const int rump_vop_open_vp_offsets[] = {
! 238: VOPARG_OFFSETOF(struct rump_vop_open_args,a_vp),
! 239: VDESC_NO_OFFSET
! 240: };
! 241: const struct vnodeop_desc rump_vop_open_desc = {
! 242: RUMP_VOP_OPEN_DESCOFFSET,
! 243: "rump_vop_open",
! 244: 0,
! 245: rump_vop_open_vp_offsets,
! 246: VDESC_NO_OFFSET,
! 247: VOPARG_OFFSETOF(struct rump_vop_open_args, a_cred),
! 248: VDESC_NO_OFFSET,
! 249: NULL,
! 250: };
! 251: int
! 252: RUMP_VOP_OPEN(struct vnode *vp,
! 253: int mode,
! 254: kauth_cred_t cred)
! 255: {
! 256: int error;
! 257: bool mpsafe;
! 258: struct rump_vop_open_args a;
! 259: #ifdef VNODE_LOCKDEBUG
! 260: int islocked_vp;
! 261: #endif
! 262: a.a_desc = VDESC(rump_vop_open);
! 263: a.a_vp = vp;
! 264: #ifdef VNODE_LOCKDEBUG
! 265: islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
! 266: if (islocked_vp != 1)
! 267: panic("rump_vop_open: vp: locked %d, expected %d", islocked_vp, 1);
! 268: #endif
! 269: a.a_mode = mode;
! 270: a.a_cred = cred;
! 271: mpsafe = (vp->v_vflag & VV_MPSAFE);
! 272: if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
! 273: error = (VCALL(vp, VOFFSET(rump_vop_open), &a));
! 274: if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
! 275: return error;
! 276: }
! 277:
! 278: const int rump_vop_close_vp_offsets[] = {
! 279: VOPARG_OFFSETOF(struct rump_vop_close_args,a_vp),
! 280: VDESC_NO_OFFSET
! 281: };
! 282: const struct vnodeop_desc rump_vop_close_desc = {
! 283: RUMP_VOP_CLOSE_DESCOFFSET,
! 284: "rump_vop_close",
! 285: 0,
! 286: rump_vop_close_vp_offsets,
! 287: VDESC_NO_OFFSET,
! 288: VOPARG_OFFSETOF(struct rump_vop_close_args, a_cred),
! 289: VDESC_NO_OFFSET,
! 290: NULL,
! 291: };
! 292: int
! 293: RUMP_VOP_CLOSE(struct vnode *vp,
! 294: int fflag,
! 295: kauth_cred_t cred)
! 296: {
! 297: int error;
! 298: bool mpsafe;
! 299: struct rump_vop_close_args a;
! 300: #ifdef VNODE_LOCKDEBUG
! 301: int islocked_vp;
! 302: #endif
! 303: a.a_desc = VDESC(rump_vop_close);
! 304: a.a_vp = vp;
! 305: #ifdef VNODE_LOCKDEBUG
! 306: islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
! 307: if (islocked_vp != 1)
! 308: panic("rump_vop_close: vp: locked %d, expected %d", islocked_vp, 1);
! 309: #endif
! 310: a.a_fflag = fflag;
! 311: a.a_cred = cred;
! 312: mpsafe = (vp->v_vflag & VV_MPSAFE);
! 313: if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
! 314: error = (VCALL(vp, VOFFSET(rump_vop_close), &a));
! 315: if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
! 316: return error;
! 317: }
! 318:
! 319: const int rump_vop_access_vp_offsets[] = {
! 320: VOPARG_OFFSETOF(struct rump_vop_access_args,a_vp),
! 321: VDESC_NO_OFFSET
! 322: };
! 323: const struct vnodeop_desc rump_vop_access_desc = {
! 324: RUMP_VOP_ACCESS_DESCOFFSET,
! 325: "rump_vop_access",
! 326: 0,
! 327: rump_vop_access_vp_offsets,
! 328: VDESC_NO_OFFSET,
! 329: VOPARG_OFFSETOF(struct rump_vop_access_args, a_cred),
! 330: VDESC_NO_OFFSET,
! 331: NULL,
! 332: };
! 333: int
! 334: RUMP_VOP_ACCESS(struct vnode *vp,
! 335: int mode,
! 336: kauth_cred_t cred)
! 337: {
! 338: int error;
! 339: bool mpsafe;
! 340: struct rump_vop_access_args a;
! 341: #ifdef VNODE_LOCKDEBUG
! 342: int islocked_vp;
! 343: #endif
! 344: a.a_desc = VDESC(rump_vop_access);
! 345: a.a_vp = vp;
! 346: #ifdef VNODE_LOCKDEBUG
! 347: islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
! 348: if (islocked_vp != 1)
! 349: panic("rump_vop_access: vp: locked %d, expected %d", islocked_vp, 1);
! 350: #endif
! 351: a.a_mode = mode;
! 352: a.a_cred = cred;
! 353: mpsafe = (vp->v_vflag & VV_MPSAFE);
! 354: if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
! 355: error = (VCALL(vp, VOFFSET(rump_vop_access), &a));
! 356: if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
! 357: return error;
! 358: }
! 359:
! 360: const int rump_vop_getattr_vp_offsets[] = {
! 361: VOPARG_OFFSETOF(struct rump_vop_getattr_args,a_vp),
! 362: VDESC_NO_OFFSET
! 363: };
! 364: const struct vnodeop_desc rump_vop_getattr_desc = {
! 365: RUMP_VOP_GETATTR_DESCOFFSET,
! 366: "rump_vop_getattr",
! 367: 0,
! 368: rump_vop_getattr_vp_offsets,
! 369: VDESC_NO_OFFSET,
! 370: VOPARG_OFFSETOF(struct rump_vop_getattr_args, a_cred),
! 371: VDESC_NO_OFFSET,
! 372: NULL,
! 373: };
! 374: int
! 375: RUMP_VOP_GETATTR(struct vnode *vp,
! 376: struct vattr *vap,
! 377: kauth_cred_t cred)
! 378: {
! 379: int error;
! 380: bool mpsafe;
! 381: struct rump_vop_getattr_args a;
! 382: #ifdef VNODE_LOCKDEBUG
! 383: #endif
! 384: a.a_desc = VDESC(rump_vop_getattr);
! 385: a.a_vp = vp;
! 386: a.a_vap = vap;
! 387: a.a_cred = cred;
! 388: mpsafe = (vp->v_vflag & VV_MPSAFE);
! 389: if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
! 390: error = (VCALL(vp, VOFFSET(rump_vop_getattr), &a));
! 391: if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
! 392: return error;
! 393: }
! 394:
! 395: const int rump_vop_setattr_vp_offsets[] = {
! 396: VOPARG_OFFSETOF(struct rump_vop_setattr_args,a_vp),
! 397: VDESC_NO_OFFSET
! 398: };
! 399: const struct vnodeop_desc rump_vop_setattr_desc = {
! 400: RUMP_VOP_SETATTR_DESCOFFSET,
! 401: "rump_vop_setattr",
! 402: 0,
! 403: rump_vop_setattr_vp_offsets,
! 404: VDESC_NO_OFFSET,
! 405: VOPARG_OFFSETOF(struct rump_vop_setattr_args, a_cred),
! 406: VDESC_NO_OFFSET,
! 407: NULL,
! 408: };
! 409: int
! 410: RUMP_VOP_SETATTR(struct vnode *vp,
! 411: struct vattr *vap,
! 412: kauth_cred_t cred)
! 413: {
! 414: int error;
! 415: bool mpsafe;
! 416: struct rump_vop_setattr_args a;
! 417: #ifdef VNODE_LOCKDEBUG
! 418: int islocked_vp;
! 419: #endif
! 420: a.a_desc = VDESC(rump_vop_setattr);
! 421: a.a_vp = vp;
! 422: #ifdef VNODE_LOCKDEBUG
! 423: islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
! 424: if (islocked_vp != 1)
! 425: panic("rump_vop_setattr: vp: locked %d, expected %d", islocked_vp, 1);
! 426: #endif
! 427: a.a_vap = vap;
! 428: a.a_cred = cred;
! 429: mpsafe = (vp->v_vflag & VV_MPSAFE);
! 430: if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
! 431: error = (VCALL(vp, VOFFSET(rump_vop_setattr), &a));
! 432: if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
! 433: return error;
! 434: }
! 435:
! 436: const int rump_vop_read_vp_offsets[] = {
! 437: VOPARG_OFFSETOF(struct rump_vop_read_args,a_vp),
! 438: VDESC_NO_OFFSET
! 439: };
! 440: const struct vnodeop_desc rump_vop_read_desc = {
! 441: RUMP_VOP_READ_DESCOFFSET,
! 442: "rump_vop_read",
! 443: 0,
! 444: rump_vop_read_vp_offsets,
! 445: VDESC_NO_OFFSET,
! 446: VOPARG_OFFSETOF(struct rump_vop_read_args, a_cred),
! 447: VDESC_NO_OFFSET,
! 448: NULL,
! 449: };
! 450: int
! 451: RUMP_VOP_READ(struct vnode *vp,
! 452: struct uio *uio,
! 453: int ioflag,
! 454: kauth_cred_t cred)
! 455: {
! 456: int error;
! 457: bool mpsafe;
! 458: struct rump_vop_read_args a;
! 459: #ifdef VNODE_LOCKDEBUG
! 460: int islocked_vp;
! 461: #endif
! 462: a.a_desc = VDESC(rump_vop_read);
! 463: a.a_vp = vp;
! 464: #ifdef VNODE_LOCKDEBUG
! 465: islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
! 466: if (islocked_vp != 1)
! 467: panic("rump_vop_read: vp: locked %d, expected %d", islocked_vp, 1);
! 468: #endif
! 469: a.a_uio = uio;
! 470: a.a_ioflag = ioflag;
! 471: a.a_cred = cred;
! 472: mpsafe = (vp->v_vflag & VV_MPSAFE);
! 473: if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
! 474: error = (VCALL(vp, VOFFSET(rump_vop_read), &a));
! 475: if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
! 476: return error;
! 477: }
! 478:
! 479: const int rump_vop_write_vp_offsets[] = {
! 480: VOPARG_OFFSETOF(struct rump_vop_write_args,a_vp),
! 481: VDESC_NO_OFFSET
! 482: };
! 483: const struct vnodeop_desc rump_vop_write_desc = {
! 484: RUMP_VOP_WRITE_DESCOFFSET,
! 485: "rump_vop_write",
! 486: 0,
! 487: rump_vop_write_vp_offsets,
! 488: VDESC_NO_OFFSET,
! 489: VOPARG_OFFSETOF(struct rump_vop_write_args, a_cred),
! 490: VDESC_NO_OFFSET,
! 491: NULL,
! 492: };
! 493: int
! 494: RUMP_VOP_WRITE(struct vnode *vp,
! 495: struct uio *uio,
! 496: int ioflag,
! 497: kauth_cred_t cred)
! 498: {
! 499: int error;
! 500: bool mpsafe;
! 501: struct rump_vop_write_args a;
! 502: #ifdef VNODE_LOCKDEBUG
! 503: int islocked_vp;
! 504: #endif
! 505: a.a_desc = VDESC(rump_vop_write);
! 506: a.a_vp = vp;
! 507: #ifdef VNODE_LOCKDEBUG
! 508: islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
! 509: if (islocked_vp != 1)
! 510: panic("rump_vop_write: vp: locked %d, expected %d", islocked_vp, 1);
! 511: #endif
! 512: a.a_uio = uio;
! 513: a.a_ioflag = ioflag;
! 514: a.a_cred = cred;
! 515: mpsafe = (vp->v_vflag & VV_MPSAFE);
! 516: if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
! 517: error = (VCALL(vp, VOFFSET(rump_vop_write), &a));
! 518: if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
! 519: return error;
! 520: }
! 521:
! 522: const int rump_vop_ioctl_vp_offsets[] = {
! 523: VOPARG_OFFSETOF(struct rump_vop_ioctl_args,a_vp),
! 524: VDESC_NO_OFFSET
! 525: };
! 526: const struct vnodeop_desc rump_vop_ioctl_desc = {
! 527: RUMP_VOP_IOCTL_DESCOFFSET,
! 528: "rump_vop_ioctl",
! 529: 0,
! 530: rump_vop_ioctl_vp_offsets,
! 531: VDESC_NO_OFFSET,
! 532: VOPARG_OFFSETOF(struct rump_vop_ioctl_args, a_cred),
! 533: VDESC_NO_OFFSET,
! 534: NULL,
! 535: };
! 536: int
! 537: RUMP_VOP_IOCTL(struct vnode *vp,
! 538: u_long command,
! 539: void *data,
! 540: int fflag,
! 541: kauth_cred_t cred)
! 542: {
! 543: int error;
! 544: bool mpsafe;
! 545: struct rump_vop_ioctl_args a;
! 546: #ifdef VNODE_LOCKDEBUG
! 547: int islocked_vp;
! 548: #endif
! 549: a.a_desc = VDESC(rump_vop_ioctl);
! 550: a.a_vp = vp;
! 551: #ifdef VNODE_LOCKDEBUG
! 552: islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0;
! 553: if (islocked_vp != 0)
! 554: panic("rump_vop_ioctl: vp: locked %d, expected %d", islocked_vp, 0);
! 555: #endif
! 556: a.a_command = command;
! 557: a.a_data = data;
! 558: a.a_fflag = fflag;
! 559: a.a_cred = cred;
! 560: mpsafe = (vp->v_vflag & VV_MPSAFE);
! 561: if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
! 562: error = (VCALL(vp, VOFFSET(rump_vop_ioctl), &a));
! 563: if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
! 564: return error;
! 565: }
! 566:
! 567: const int rump_vop_fcntl_vp_offsets[] = {
! 568: VOPARG_OFFSETOF(struct rump_vop_fcntl_args,a_vp),
! 569: VDESC_NO_OFFSET
! 570: };
! 571: const struct vnodeop_desc rump_vop_fcntl_desc = {
! 572: RUMP_VOP_FCNTL_DESCOFFSET,
! 573: "rump_vop_fcntl",
! 574: 0,
! 575: rump_vop_fcntl_vp_offsets,
! 576: VDESC_NO_OFFSET,
! 577: VOPARG_OFFSETOF(struct rump_vop_fcntl_args, a_cred),
! 578: VDESC_NO_OFFSET,
! 579: NULL,
! 580: };
! 581: int
! 582: RUMP_VOP_FCNTL(struct vnode *vp,
! 583: u_int command,
! 584: void *data,
! 585: int fflag,
! 586: kauth_cred_t cred)
! 587: {
! 588: int error;
! 589: bool mpsafe;
! 590: struct rump_vop_fcntl_args a;
! 591: #ifdef VNODE_LOCKDEBUG
! 592: int islocked_vp;
! 593: #endif
! 594: a.a_desc = VDESC(rump_vop_fcntl);
! 595: a.a_vp = vp;
! 596: #ifdef VNODE_LOCKDEBUG
! 597: islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0;
! 598: if (islocked_vp != 0)
! 599: panic("rump_vop_fcntl: vp: locked %d, expected %d", islocked_vp, 0);
! 600: #endif
! 601: a.a_command = command;
! 602: a.a_data = data;
! 603: a.a_fflag = fflag;
! 604: a.a_cred = cred;
! 605: mpsafe = (vp->v_vflag & VV_MPSAFE);
! 606: if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
! 607: error = (VCALL(vp, VOFFSET(rump_vop_fcntl), &a));
! 608: if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
! 609: return error;
! 610: }
! 611:
! 612: const int rump_vop_poll_vp_offsets[] = {
! 613: VOPARG_OFFSETOF(struct rump_vop_poll_args,a_vp),
! 614: VDESC_NO_OFFSET
! 615: };
! 616: const struct vnodeop_desc rump_vop_poll_desc = {
! 617: RUMP_VOP_POLL_DESCOFFSET,
! 618: "rump_vop_poll",
! 619: 0,
! 620: rump_vop_poll_vp_offsets,
! 621: VDESC_NO_OFFSET,
! 622: VDESC_NO_OFFSET,
! 623: VDESC_NO_OFFSET,
! 624: NULL,
! 625: };
! 626: int
! 627: RUMP_VOP_POLL(struct vnode *vp,
! 628: int events)
! 629: {
! 630: int error;
! 631: bool mpsafe;
! 632: struct rump_vop_poll_args a;
! 633: #ifdef VNODE_LOCKDEBUG
! 634: int islocked_vp;
! 635: #endif
! 636: a.a_desc = VDESC(rump_vop_poll);
! 637: a.a_vp = vp;
! 638: #ifdef VNODE_LOCKDEBUG
! 639: islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0;
! 640: if (islocked_vp != 0)
! 641: panic("rump_vop_poll: vp: locked %d, expected %d", islocked_vp, 0);
! 642: #endif
! 643: a.a_events = events;
! 644: mpsafe = (vp->v_vflag & VV_MPSAFE);
! 645: if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
! 646: error = (VCALL(vp, VOFFSET(rump_vop_poll), &a));
! 647: if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
! 648: return error;
! 649: }
! 650:
! 651: const int rump_vop_kqfilter_vp_offsets[] = {
! 652: VOPARG_OFFSETOF(struct rump_vop_kqfilter_args,a_vp),
! 653: VDESC_NO_OFFSET
! 654: };
! 655: const struct vnodeop_desc rump_vop_kqfilter_desc = {
! 656: RUMP_VOP_KQFILTER_DESCOFFSET,
! 657: "rump_vop_kqfilter",
! 658: 0,
! 659: rump_vop_kqfilter_vp_offsets,
! 660: VDESC_NO_OFFSET,
! 661: VDESC_NO_OFFSET,
! 662: VDESC_NO_OFFSET,
! 663: NULL,
! 664: };
! 665: int
! 666: RUMP_VOP_KQFILTER(struct vnode *vp,
! 667: struct knote *kn)
! 668: {
! 669: int error;
! 670: bool mpsafe;
! 671: struct rump_vop_kqfilter_args a;
! 672: #ifdef VNODE_LOCKDEBUG
! 673: int islocked_vp;
! 674: #endif
! 675: a.a_desc = VDESC(rump_vop_kqfilter);
! 676: a.a_vp = vp;
! 677: #ifdef VNODE_LOCKDEBUG
! 678: islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0;
! 679: if (islocked_vp != 0)
! 680: panic("rump_vop_kqfilter: vp: locked %d, expected %d", islocked_vp, 0);
! 681: #endif
! 682: a.a_kn = kn;
! 683: mpsafe = (vp->v_vflag & VV_MPSAFE);
! 684: if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
! 685: error = (VCALL(vp, VOFFSET(rump_vop_kqfilter), &a));
! 686: if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
! 687: return error;
! 688: }
! 689:
! 690: const int rump_vop_revoke_vp_offsets[] = {
! 691: VOPARG_OFFSETOF(struct rump_vop_revoke_args,a_vp),
! 692: VDESC_NO_OFFSET
! 693: };
! 694: const struct vnodeop_desc rump_vop_revoke_desc = {
! 695: RUMP_VOP_REVOKE_DESCOFFSET,
! 696: "rump_vop_revoke",
! 697: 0,
! 698: rump_vop_revoke_vp_offsets,
! 699: VDESC_NO_OFFSET,
! 700: VDESC_NO_OFFSET,
! 701: VDESC_NO_OFFSET,
! 702: NULL,
! 703: };
! 704: int
! 705: RUMP_VOP_REVOKE(struct vnode *vp,
! 706: int flags)
! 707: {
! 708: int error;
! 709: bool mpsafe;
! 710: struct rump_vop_revoke_args a;
! 711: #ifdef VNODE_LOCKDEBUG
! 712: int islocked_vp;
! 713: #endif
! 714: a.a_desc = VDESC(rump_vop_revoke);
! 715: a.a_vp = vp;
! 716: #ifdef VNODE_LOCKDEBUG
! 717: islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0;
! 718: if (islocked_vp != 0)
! 719: panic("rump_vop_revoke: vp: locked %d, expected %d", islocked_vp, 0);
! 720: #endif
! 721: a.a_flags = flags;
! 722: mpsafe = (vp->v_vflag & VV_MPSAFE);
! 723: if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
! 724: error = (VCALL(vp, VOFFSET(rump_vop_revoke), &a));
! 725: if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
! 726: return error;
! 727: }
! 728:
! 729: const int rump_vop_mmap_vp_offsets[] = {
! 730: VOPARG_OFFSETOF(struct rump_vop_mmap_args,a_vp),
! 731: VDESC_NO_OFFSET
! 732: };
! 733: const struct vnodeop_desc rump_vop_mmap_desc = {
! 734: RUMP_VOP_MMAP_DESCOFFSET,
! 735: "rump_vop_mmap",
! 736: 0,
! 737: rump_vop_mmap_vp_offsets,
! 738: VDESC_NO_OFFSET,
! 739: VOPARG_OFFSETOF(struct rump_vop_mmap_args, a_cred),
! 740: VDESC_NO_OFFSET,
! 741: NULL,
! 742: };
! 743: int
! 744: RUMP_VOP_MMAP(struct vnode *vp,
! 745: int prot,
! 746: kauth_cred_t cred)
! 747: {
! 748: int error;
! 749: bool mpsafe;
! 750: struct rump_vop_mmap_args a;
! 751: #ifdef VNODE_LOCKDEBUG
! 752: #endif
! 753: a.a_desc = VDESC(rump_vop_mmap);
! 754: a.a_vp = vp;
! 755: a.a_prot = prot;
! 756: a.a_cred = cred;
! 757: mpsafe = (vp->v_vflag & VV_MPSAFE);
! 758: if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
! 759: error = (VCALL(vp, VOFFSET(rump_vop_mmap), &a));
! 760: if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
! 761: return error;
! 762: }
! 763:
! 764: const int rump_vop_fsync_vp_offsets[] = {
! 765: VOPARG_OFFSETOF(struct rump_vop_fsync_args,a_vp),
! 766: VDESC_NO_OFFSET
! 767: };
! 768: const struct vnodeop_desc rump_vop_fsync_desc = {
! 769: RUMP_VOP_FSYNC_DESCOFFSET,
! 770: "rump_vop_fsync",
! 771: 0,
! 772: rump_vop_fsync_vp_offsets,
! 773: VDESC_NO_OFFSET,
! 774: VOPARG_OFFSETOF(struct rump_vop_fsync_args, a_cred),
! 775: VDESC_NO_OFFSET,
! 776: NULL,
! 777: };
! 778: int
! 779: RUMP_VOP_FSYNC(struct vnode *vp,
! 780: kauth_cred_t cred,
! 781: int flags,
! 782: off_t offlo,
! 783: off_t offhi)
! 784: {
! 785: int error;
! 786: bool mpsafe;
! 787: struct rump_vop_fsync_args a;
! 788: #ifdef VNODE_LOCKDEBUG
! 789: int islocked_vp;
! 790: #endif
! 791: a.a_desc = VDESC(rump_vop_fsync);
! 792: a.a_vp = vp;
! 793: #ifdef VNODE_LOCKDEBUG
! 794: islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
! 795: if (islocked_vp != 1)
! 796: panic("rump_vop_fsync: vp: locked %d, expected %d", islocked_vp, 1);
! 797: #endif
! 798: a.a_cred = cred;
! 799: a.a_flags = flags;
! 800: a.a_offlo = offlo;
! 801: a.a_offhi = offhi;
! 802: mpsafe = (vp->v_vflag & VV_MPSAFE);
! 803: if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
! 804: error = (VCALL(vp, VOFFSET(rump_vop_fsync), &a));
! 805: if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
! 806: return error;
! 807: }
! 808:
! 809: const int rump_vop_seek_vp_offsets[] = {
! 810: VOPARG_OFFSETOF(struct rump_vop_seek_args,a_vp),
! 811: VDESC_NO_OFFSET
! 812: };
! 813: const struct vnodeop_desc rump_vop_seek_desc = {
! 814: RUMP_VOP_SEEK_DESCOFFSET,
! 815: "rump_vop_seek",
! 816: 0,
! 817: rump_vop_seek_vp_offsets,
! 818: VDESC_NO_OFFSET,
! 819: VOPARG_OFFSETOF(struct rump_vop_seek_args, a_cred),
! 820: VDESC_NO_OFFSET,
! 821: NULL,
! 822: };
! 823: int
! 824: RUMP_VOP_SEEK(struct vnode *vp,
! 825: off_t oldoff,
! 826: off_t newoff,
! 827: kauth_cred_t cred)
! 828: {
! 829: int error;
! 830: bool mpsafe;
! 831: struct rump_vop_seek_args a;
! 832: #ifdef VNODE_LOCKDEBUG
! 833: #endif
! 834: a.a_desc = VDESC(rump_vop_seek);
! 835: a.a_vp = vp;
! 836: a.a_oldoff = oldoff;
! 837: a.a_newoff = newoff;
! 838: a.a_cred = cred;
! 839: mpsafe = (vp->v_vflag & VV_MPSAFE);
! 840: if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
! 841: error = (VCALL(vp, VOFFSET(rump_vop_seek), &a));
! 842: if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
! 843: return error;
! 844: }
! 845:
! 846: const int rump_vop_remove_vp_offsets[] = {
! 847: VOPARG_OFFSETOF(struct rump_vop_remove_args,a_dvp),
! 848: VOPARG_OFFSETOF(struct rump_vop_remove_args,a_vp),
! 849: VDESC_NO_OFFSET
! 850: };
! 851: const struct vnodeop_desc rump_vop_remove_desc = {
! 852: RUMP_VOP_REMOVE_DESCOFFSET,
! 853: "rump_vop_remove",
! 854: 0 | VDESC_VP0_WILLPUT | VDESC_VP1_WILLPUT,
! 855: rump_vop_remove_vp_offsets,
! 856: VDESC_NO_OFFSET,
! 857: VDESC_NO_OFFSET,
! 858: VOPARG_OFFSETOF(struct rump_vop_remove_args, a_cnp),
! 859: NULL,
! 860: };
! 861: int
! 862: RUMP_VOP_REMOVE(struct vnode *dvp,
! 863: struct vnode *vp,
! 864: struct componentname *cnp)
! 865: {
! 866: int error;
! 867: bool mpsafe;
! 868: struct rump_vop_remove_args a;
! 869: #ifdef VNODE_LOCKDEBUG
! 870: int islocked_dvp;
! 871: int islocked_vp;
! 872: #endif
! 873: a.a_desc = VDESC(rump_vop_remove);
! 874: a.a_dvp = dvp;
! 875: #ifdef VNODE_LOCKDEBUG
! 876: islocked_dvp = (dvp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1;
! 877: if (islocked_dvp != 1)
! 878: panic("rump_vop_remove: dvp: locked %d, expected %d", islocked_dvp, 1);
! 879: #endif
! 880: a.a_vp = vp;
! 881: #ifdef VNODE_LOCKDEBUG
! 882: islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
! 883: if (islocked_vp != 1)
! 884: panic("rump_vop_remove: vp: locked %d, expected %d", islocked_vp, 1);
! 885: #endif
! 886: a.a_cnp = cnp;
! 887: mpsafe = (dvp->v_vflag & VV_MPSAFE);
! 888: if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
! 889: error = (VCALL(dvp, VOFFSET(rump_vop_remove), &a));
! 890: if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
! 891: return error;
! 892: }
! 893:
! 894: const int rump_vop_link_vp_offsets[] = {
! 895: VOPARG_OFFSETOF(struct rump_vop_link_args,a_dvp),
! 896: VOPARG_OFFSETOF(struct rump_vop_link_args,a_vp),
! 897: VDESC_NO_OFFSET
! 898: };
! 899: const struct vnodeop_desc rump_vop_link_desc = {
! 900: RUMP_VOP_LINK_DESCOFFSET,
! 901: "rump_vop_link",
! 902: 0 | VDESC_VP0_WILLPUT,
! 903: rump_vop_link_vp_offsets,
! 904: VDESC_NO_OFFSET,
! 905: VDESC_NO_OFFSET,
! 906: VOPARG_OFFSETOF(struct rump_vop_link_args, a_cnp),
! 907: NULL,
! 908: };
! 909: int
! 910: RUMP_VOP_LINK(struct vnode *dvp,
! 911: struct vnode *vp,
! 912: struct componentname *cnp)
! 913: {
! 914: int error;
! 915: bool mpsafe;
! 916: struct rump_vop_link_args a;
! 917: #ifdef VNODE_LOCKDEBUG
! 918: int islocked_dvp;
! 919: int islocked_vp;
! 920: #endif
! 921: a.a_desc = VDESC(rump_vop_link);
! 922: a.a_dvp = dvp;
! 923: #ifdef VNODE_LOCKDEBUG
! 924: islocked_dvp = (dvp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1;
! 925: if (islocked_dvp != 1)
! 926: panic("rump_vop_link: dvp: locked %d, expected %d", islocked_dvp, 1);
! 927: #endif
! 928: a.a_vp = vp;
! 929: #ifdef VNODE_LOCKDEBUG
! 930: islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0;
! 931: if (islocked_vp != 0)
! 932: panic("rump_vop_link: vp: locked %d, expected %d", islocked_vp, 0);
! 933: #endif
! 934: a.a_cnp = cnp;
! 935: mpsafe = (dvp->v_vflag & VV_MPSAFE);
! 936: if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
! 937: error = (VCALL(dvp, VOFFSET(rump_vop_link), &a));
! 938: if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
! 939: return error;
! 940: }
! 941:
! 942: const int rump_vop_rename_vp_offsets[] = {
! 943: VOPARG_OFFSETOF(struct rump_vop_rename_args,a_fdvp),
! 944: VOPARG_OFFSETOF(struct rump_vop_rename_args,a_fvp),
! 945: VOPARG_OFFSETOF(struct rump_vop_rename_args,a_tdvp),
! 946: VOPARG_OFFSETOF(struct rump_vop_rename_args,a_tvp),
! 947: VDESC_NO_OFFSET
! 948: };
! 949: const struct vnodeop_desc rump_vop_rename_desc = {
! 950: RUMP_VOP_RENAME_DESCOFFSET,
! 951: "rump_vop_rename",
! 952: 0 | VDESC_VP0_WILLRELE | VDESC_VP1_WILLRELE | VDESC_VP2_WILLPUT | VDESC_VP3_WILLPUT,
! 953: rump_vop_rename_vp_offsets,
! 954: VDESC_NO_OFFSET,
! 955: VDESC_NO_OFFSET,
! 956: VOPARG_OFFSETOF(struct rump_vop_rename_args, a_fcnp),
! 957: NULL,
! 958: };
! 959: int
! 960: RUMP_VOP_RENAME(struct vnode *fdvp,
! 961: struct vnode *fvp,
! 962: struct componentname *fcnp,
! 963: struct vnode *tdvp,
! 964: struct vnode *tvp,
! 965: struct componentname *tcnp)
! 966: {
! 967: int error;
! 968: bool mpsafe;
! 969: struct rump_vop_rename_args a;
! 970: #ifdef VNODE_LOCKDEBUG
! 971: int islocked_fdvp;
! 972: int islocked_fvp;
! 973: int islocked_tdvp;
! 974: #endif
! 975: a.a_desc = VDESC(rump_vop_rename);
! 976: a.a_fdvp = fdvp;
! 977: #ifdef VNODE_LOCKDEBUG
! 978: islocked_fdvp = (fdvp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(fdvp) == LK_EXCLUSIVE) : 0;
! 979: if (islocked_fdvp != 0)
! 980: panic("rump_vop_rename: fdvp: locked %d, expected %d", islocked_fdvp, 0);
! 981: #endif
! 982: a.a_fvp = fvp;
! 983: #ifdef VNODE_LOCKDEBUG
! 984: islocked_fvp = (fvp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(fvp) == LK_EXCLUSIVE) : 0;
! 985: if (islocked_fvp != 0)
! 986: panic("rump_vop_rename: fvp: locked %d, expected %d", islocked_fvp, 0);
! 987: #endif
! 988: a.a_fcnp = fcnp;
! 989: a.a_tdvp = tdvp;
! 990: #ifdef VNODE_LOCKDEBUG
! 991: islocked_tdvp = (tdvp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(tdvp) == LK_EXCLUSIVE) : 1;
! 992: if (islocked_tdvp != 1)
! 993: panic("rump_vop_rename: tdvp: locked %d, expected %d", islocked_tdvp, 1);
! 994: #endif
! 995: a.a_tvp = tvp;
! 996: a.a_tcnp = tcnp;
! 997: mpsafe = (fdvp->v_vflag & VV_MPSAFE);
! 998: if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
! 999: error = (VCALL(fdvp, VOFFSET(rump_vop_rename), &a));
! 1000: if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
! 1001: return error;
! 1002: }
! 1003:
! 1004: const int rump_vop_mkdir_vp_offsets[] = {
! 1005: VOPARG_OFFSETOF(struct rump_vop_mkdir_args,a_dvp),
! 1006: VDESC_NO_OFFSET
! 1007: };
! 1008: const struct vnodeop_desc rump_vop_mkdir_desc = {
! 1009: RUMP_VOP_MKDIR_DESCOFFSET,
! 1010: "rump_vop_mkdir",
! 1011: 0 | VDESC_VP0_WILLPUT,
! 1012: rump_vop_mkdir_vp_offsets,
! 1013: VOPARG_OFFSETOF(struct rump_vop_mkdir_args, a_vpp),
! 1014: VDESC_NO_OFFSET,
! 1015: VOPARG_OFFSETOF(struct rump_vop_mkdir_args, a_cnp),
! 1016: NULL,
! 1017: };
! 1018: int
! 1019: RUMP_VOP_MKDIR(struct vnode *dvp,
! 1020: struct vnode **vpp,
! 1021: struct componentname *cnp,
! 1022: struct vattr *vap)
! 1023: {
! 1024: int error;
! 1025: bool mpsafe;
! 1026: struct rump_vop_mkdir_args a;
! 1027: #ifdef VNODE_LOCKDEBUG
! 1028: int islocked_dvp;
! 1029: #endif
! 1030: a.a_desc = VDESC(rump_vop_mkdir);
! 1031: a.a_dvp = dvp;
! 1032: #ifdef VNODE_LOCKDEBUG
! 1033: islocked_dvp = (dvp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1;
! 1034: if (islocked_dvp != 1)
! 1035: panic("rump_vop_mkdir: dvp: locked %d, expected %d", islocked_dvp, 1);
! 1036: #endif
! 1037: a.a_vpp = vpp;
! 1038: a.a_cnp = cnp;
! 1039: a.a_vap = vap;
! 1040: mpsafe = (dvp->v_vflag & VV_MPSAFE);
! 1041: if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
! 1042: error = (VCALL(dvp, VOFFSET(rump_vop_mkdir), &a));
! 1043: if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
! 1044: #ifdef DIAGNOSTIC
! 1045: if (error == 0)
! 1046: KASSERT((*vpp)->v_size != VSIZENOTSET
! 1047: && (*vpp)->v_writesize != VSIZENOTSET);
! 1048: #endif /* DIAGNOSTIC */
! 1049: return error;
! 1050: }
! 1051:
! 1052: const int rump_vop_rmdir_vp_offsets[] = {
! 1053: VOPARG_OFFSETOF(struct rump_vop_rmdir_args,a_dvp),
! 1054: VOPARG_OFFSETOF(struct rump_vop_rmdir_args,a_vp),
! 1055: VDESC_NO_OFFSET
! 1056: };
! 1057: const struct vnodeop_desc rump_vop_rmdir_desc = {
! 1058: RUMP_VOP_RMDIR_DESCOFFSET,
! 1059: "rump_vop_rmdir",
! 1060: 0 | VDESC_VP0_WILLPUT | VDESC_VP1_WILLPUT,
! 1061: rump_vop_rmdir_vp_offsets,
! 1062: VDESC_NO_OFFSET,
! 1063: VDESC_NO_OFFSET,
! 1064: VOPARG_OFFSETOF(struct rump_vop_rmdir_args, a_cnp),
! 1065: NULL,
! 1066: };
! 1067: int
! 1068: RUMP_VOP_RMDIR(struct vnode *dvp,
! 1069: struct vnode *vp,
! 1070: struct componentname *cnp)
! 1071: {
! 1072: int error;
! 1073: bool mpsafe;
! 1074: struct rump_vop_rmdir_args a;
! 1075: #ifdef VNODE_LOCKDEBUG
! 1076: int islocked_dvp;
! 1077: int islocked_vp;
! 1078: #endif
! 1079: a.a_desc = VDESC(rump_vop_rmdir);
! 1080: a.a_dvp = dvp;
! 1081: #ifdef VNODE_LOCKDEBUG
! 1082: islocked_dvp = (dvp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1;
! 1083: if (islocked_dvp != 1)
! 1084: panic("rump_vop_rmdir: dvp: locked %d, expected %d", islocked_dvp, 1);
! 1085: #endif
! 1086: a.a_vp = vp;
! 1087: #ifdef VNODE_LOCKDEBUG
! 1088: islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
! 1089: if (islocked_vp != 1)
! 1090: panic("rump_vop_rmdir: vp: locked %d, expected %d", islocked_vp, 1);
! 1091: #endif
! 1092: a.a_cnp = cnp;
! 1093: mpsafe = (dvp->v_vflag & VV_MPSAFE);
! 1094: if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
! 1095: error = (VCALL(dvp, VOFFSET(rump_vop_rmdir), &a));
! 1096: if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
! 1097: return error;
! 1098: }
! 1099:
! 1100: const int rump_vop_symlink_vp_offsets[] = {
! 1101: VOPARG_OFFSETOF(struct rump_vop_symlink_args,a_dvp),
! 1102: VDESC_NO_OFFSET
! 1103: };
! 1104: const struct vnodeop_desc rump_vop_symlink_desc = {
! 1105: RUMP_VOP_SYMLINK_DESCOFFSET,
! 1106: "rump_vop_symlink",
! 1107: 0 | VDESC_VP0_WILLPUT,
! 1108: rump_vop_symlink_vp_offsets,
! 1109: VOPARG_OFFSETOF(struct rump_vop_symlink_args, a_vpp),
! 1110: VDESC_NO_OFFSET,
! 1111: VOPARG_OFFSETOF(struct rump_vop_symlink_args, a_cnp),
! 1112: NULL,
! 1113: };
! 1114: int
! 1115: RUMP_VOP_SYMLINK(struct vnode *dvp,
! 1116: struct vnode **vpp,
! 1117: struct componentname *cnp,
! 1118: struct vattr *vap,
! 1119: char *target)
! 1120: {
! 1121: int error;
! 1122: bool mpsafe;
! 1123: struct rump_vop_symlink_args a;
! 1124: #ifdef VNODE_LOCKDEBUG
! 1125: int islocked_dvp;
! 1126: #endif
! 1127: a.a_desc = VDESC(rump_vop_symlink);
! 1128: a.a_dvp = dvp;
! 1129: #ifdef VNODE_LOCKDEBUG
! 1130: islocked_dvp = (dvp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1;
! 1131: if (islocked_dvp != 1)
! 1132: panic("rump_vop_symlink: dvp: locked %d, expected %d", islocked_dvp, 1);
! 1133: #endif
! 1134: a.a_vpp = vpp;
! 1135: a.a_cnp = cnp;
! 1136: a.a_vap = vap;
! 1137: a.a_target = target;
! 1138: mpsafe = (dvp->v_vflag & VV_MPSAFE);
! 1139: if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
! 1140: error = (VCALL(dvp, VOFFSET(rump_vop_symlink), &a));
! 1141: if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
! 1142: #ifdef DIAGNOSTIC
! 1143: if (error == 0)
! 1144: KASSERT((*vpp)->v_size != VSIZENOTSET
! 1145: && (*vpp)->v_writesize != VSIZENOTSET);
! 1146: #endif /* DIAGNOSTIC */
! 1147: return error;
! 1148: }
! 1149:
! 1150: const int rump_vop_readdir_vp_offsets[] = {
! 1151: VOPARG_OFFSETOF(struct rump_vop_readdir_args,a_vp),
! 1152: VDESC_NO_OFFSET
! 1153: };
! 1154: const struct vnodeop_desc rump_vop_readdir_desc = {
! 1155: RUMP_VOP_READDIR_DESCOFFSET,
! 1156: "rump_vop_readdir",
! 1157: 0,
! 1158: rump_vop_readdir_vp_offsets,
! 1159: VDESC_NO_OFFSET,
! 1160: VOPARG_OFFSETOF(struct rump_vop_readdir_args, a_cred),
! 1161: VDESC_NO_OFFSET,
! 1162: NULL,
! 1163: };
! 1164: int
! 1165: RUMP_VOP_READDIR(struct vnode *vp,
! 1166: struct uio *uio,
! 1167: kauth_cred_t cred,
! 1168: int *eofflag,
! 1169: off_t **cookies,
! 1170: int *ncookies)
! 1171: {
! 1172: int error;
! 1173: bool mpsafe;
! 1174: struct rump_vop_readdir_args a;
! 1175: #ifdef VNODE_LOCKDEBUG
! 1176: int islocked_vp;
! 1177: #endif
! 1178: a.a_desc = VDESC(rump_vop_readdir);
! 1179: a.a_vp = vp;
! 1180: #ifdef VNODE_LOCKDEBUG
! 1181: islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
! 1182: if (islocked_vp != 1)
! 1183: panic("rump_vop_readdir: vp: locked %d, expected %d", islocked_vp, 1);
! 1184: #endif
! 1185: a.a_uio = uio;
! 1186: a.a_cred = cred;
! 1187: a.a_eofflag = eofflag;
! 1188: a.a_cookies = cookies;
! 1189: a.a_ncookies = ncookies;
! 1190: mpsafe = (vp->v_vflag & VV_MPSAFE);
! 1191: if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
! 1192: error = (VCALL(vp, VOFFSET(rump_vop_readdir), &a));
! 1193: if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
! 1194: return error;
! 1195: }
! 1196:
! 1197: const int rump_vop_readlink_vp_offsets[] = {
! 1198: VOPARG_OFFSETOF(struct rump_vop_readlink_args,a_vp),
! 1199: VDESC_NO_OFFSET
! 1200: };
! 1201: const struct vnodeop_desc rump_vop_readlink_desc = {
! 1202: RUMP_VOP_READLINK_DESCOFFSET,
! 1203: "rump_vop_readlink",
! 1204: 0,
! 1205: rump_vop_readlink_vp_offsets,
! 1206: VDESC_NO_OFFSET,
! 1207: VOPARG_OFFSETOF(struct rump_vop_readlink_args, a_cred),
! 1208: VDESC_NO_OFFSET,
! 1209: NULL,
! 1210: };
! 1211: int
! 1212: RUMP_VOP_READLINK(struct vnode *vp,
! 1213: struct uio *uio,
! 1214: kauth_cred_t cred)
! 1215: {
! 1216: int error;
! 1217: bool mpsafe;
! 1218: struct rump_vop_readlink_args a;
! 1219: #ifdef VNODE_LOCKDEBUG
! 1220: int islocked_vp;
! 1221: #endif
! 1222: a.a_desc = VDESC(rump_vop_readlink);
! 1223: a.a_vp = vp;
! 1224: #ifdef VNODE_LOCKDEBUG
! 1225: islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
! 1226: if (islocked_vp != 1)
! 1227: panic("rump_vop_readlink: vp: locked %d, expected %d", islocked_vp, 1);
! 1228: #endif
! 1229: a.a_uio = uio;
! 1230: a.a_cred = cred;
! 1231: mpsafe = (vp->v_vflag & VV_MPSAFE);
! 1232: if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
! 1233: error = (VCALL(vp, VOFFSET(rump_vop_readlink), &a));
! 1234: if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
! 1235: return error;
! 1236: }
! 1237:
! 1238: const int rump_vop_abortop_vp_offsets[] = {
! 1239: VOPARG_OFFSETOF(struct rump_vop_abortop_args,a_dvp),
! 1240: VDESC_NO_OFFSET
! 1241: };
! 1242: const struct vnodeop_desc rump_vop_abortop_desc = {
! 1243: RUMP_VOP_ABORTOP_DESCOFFSET,
! 1244: "rump_vop_abortop",
! 1245: 0,
! 1246: rump_vop_abortop_vp_offsets,
! 1247: VDESC_NO_OFFSET,
! 1248: VDESC_NO_OFFSET,
! 1249: VOPARG_OFFSETOF(struct rump_vop_abortop_args, a_cnp),
! 1250: NULL,
! 1251: };
! 1252: int
! 1253: RUMP_VOP_ABORTOP(struct vnode *dvp,
! 1254: struct componentname *cnp)
! 1255: {
! 1256: int error;
! 1257: bool mpsafe;
! 1258: struct rump_vop_abortop_args a;
! 1259: #ifdef VNODE_LOCKDEBUG
! 1260: #endif
! 1261: a.a_desc = VDESC(rump_vop_abortop);
! 1262: a.a_dvp = dvp;
! 1263: a.a_cnp = cnp;
! 1264: mpsafe = (dvp->v_vflag & VV_MPSAFE);
! 1265: if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
! 1266: error = (VCALL(dvp, VOFFSET(rump_vop_abortop), &a));
! 1267: if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
! 1268: return error;
! 1269: }
! 1270:
! 1271: const int rump_vop_inactive_vp_offsets[] = {
! 1272: VOPARG_OFFSETOF(struct rump_vop_inactive_args,a_vp),
! 1273: VDESC_NO_OFFSET
! 1274: };
! 1275: const struct vnodeop_desc rump_vop_inactive_desc = {
! 1276: RUMP_VOP_INACTIVE_DESCOFFSET,
! 1277: "rump_vop_inactive",
! 1278: 0 | VDESC_VP0_WILLUNLOCK,
! 1279: rump_vop_inactive_vp_offsets,
! 1280: VDESC_NO_OFFSET,
! 1281: VDESC_NO_OFFSET,
! 1282: VDESC_NO_OFFSET,
! 1283: NULL,
! 1284: };
! 1285: int
! 1286: RUMP_VOP_INACTIVE(struct vnode *vp,
! 1287: bool *recycle)
! 1288: {
! 1289: int error;
! 1290: bool mpsafe;
! 1291: struct rump_vop_inactive_args a;
! 1292: #ifdef VNODE_LOCKDEBUG
! 1293: int islocked_vp;
! 1294: #endif
! 1295: a.a_desc = VDESC(rump_vop_inactive);
! 1296: a.a_vp = vp;
! 1297: #ifdef VNODE_LOCKDEBUG
! 1298: islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
! 1299: if (islocked_vp != 1)
! 1300: panic("rump_vop_inactive: vp: locked %d, expected %d", islocked_vp, 1);
! 1301: #endif
! 1302: a.a_recycle = recycle;
! 1303: mpsafe = (vp->v_vflag & VV_MPSAFE);
! 1304: if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
! 1305: error = (VCALL(vp, VOFFSET(rump_vop_inactive), &a));
! 1306: if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
! 1307: return error;
! 1308: }
! 1309:
! 1310: const int rump_vop_reclaim_vp_offsets[] = {
! 1311: VOPARG_OFFSETOF(struct rump_vop_reclaim_args,a_vp),
! 1312: VDESC_NO_OFFSET
! 1313: };
! 1314: const struct vnodeop_desc rump_vop_reclaim_desc = {
! 1315: RUMP_VOP_RECLAIM_DESCOFFSET,
! 1316: "rump_vop_reclaim",
! 1317: 0,
! 1318: rump_vop_reclaim_vp_offsets,
! 1319: VDESC_NO_OFFSET,
! 1320: VDESC_NO_OFFSET,
! 1321: VDESC_NO_OFFSET,
! 1322: NULL,
! 1323: };
! 1324: int
! 1325: RUMP_VOP_RECLAIM(struct vnode *vp)
! 1326: {
! 1327: int error;
! 1328: bool mpsafe;
! 1329: struct rump_vop_reclaim_args a;
! 1330: #ifdef VNODE_LOCKDEBUG
! 1331: int islocked_vp;
! 1332: #endif
! 1333: a.a_desc = VDESC(rump_vop_reclaim);
! 1334: a.a_vp = vp;
! 1335: #ifdef VNODE_LOCKDEBUG
! 1336: islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0;
! 1337: if (islocked_vp != 0)
! 1338: panic("rump_vop_reclaim: vp: locked %d, expected %d", islocked_vp, 0);
! 1339: #endif
! 1340: mpsafe = (vp->v_vflag & VV_MPSAFE);
! 1341: if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
! 1342: error = (VCALL(vp, VOFFSET(rump_vop_reclaim), &a));
! 1343: if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
! 1344: return error;
! 1345: }
! 1346:
! 1347: const int rump_vop_lock_vp_offsets[] = {
! 1348: VOPARG_OFFSETOF(struct rump_vop_lock_args,a_vp),
! 1349: VDESC_NO_OFFSET
! 1350: };
! 1351: const struct vnodeop_desc rump_vop_lock_desc = {
! 1352: RUMP_VOP_LOCK_DESCOFFSET,
! 1353: "rump_vop_lock",
! 1354: 0,
! 1355: rump_vop_lock_vp_offsets,
! 1356: VDESC_NO_OFFSET,
! 1357: VDESC_NO_OFFSET,
! 1358: VDESC_NO_OFFSET,
! 1359: NULL,
! 1360: };
! 1361: int
! 1362: RUMP_VOP_LOCK(struct vnode *vp,
! 1363: int flags)
! 1364: {
! 1365: int error;
! 1366: bool mpsafe;
! 1367: struct rump_vop_lock_args a;
! 1368: #ifdef VNODE_LOCKDEBUG
! 1369: int islocked_vp;
! 1370: #endif
! 1371: a.a_desc = VDESC(rump_vop_lock);
! 1372: a.a_vp = vp;
! 1373: #ifdef VNODE_LOCKDEBUG
! 1374: islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0;
! 1375: if (islocked_vp != 0)
! 1376: panic("rump_vop_lock: vp: locked %d, expected %d", islocked_vp, 0);
! 1377: #endif
! 1378: a.a_flags = flags;
! 1379: mpsafe = (vp->v_vflag & VV_MPSAFE);
! 1380: if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
! 1381: error = (VCALL(vp, VOFFSET(rump_vop_lock), &a));
! 1382: if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
! 1383: return error;
! 1384: }
! 1385:
! 1386: const int rump_vop_unlock_vp_offsets[] = {
! 1387: VOPARG_OFFSETOF(struct rump_vop_unlock_args,a_vp),
! 1388: VDESC_NO_OFFSET
! 1389: };
! 1390: const struct vnodeop_desc rump_vop_unlock_desc = {
! 1391: RUMP_VOP_UNLOCK_DESCOFFSET,
! 1392: "rump_vop_unlock",
! 1393: 0,
! 1394: rump_vop_unlock_vp_offsets,
! 1395: VDESC_NO_OFFSET,
! 1396: VDESC_NO_OFFSET,
! 1397: VDESC_NO_OFFSET,
! 1398: NULL,
! 1399: };
! 1400: int
! 1401: RUMP_VOP_UNLOCK(struct vnode *vp,
! 1402: int flags)
! 1403: {
! 1404: int error;
! 1405: bool mpsafe;
! 1406: struct rump_vop_unlock_args a;
! 1407: #ifdef VNODE_LOCKDEBUG
! 1408: int islocked_vp;
! 1409: #endif
! 1410: a.a_desc = VDESC(rump_vop_unlock);
! 1411: a.a_vp = vp;
! 1412: #ifdef VNODE_LOCKDEBUG
! 1413: islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
! 1414: if (islocked_vp != 1)
! 1415: panic("rump_vop_unlock: vp: locked %d, expected %d", islocked_vp, 1);
! 1416: #endif
! 1417: a.a_flags = flags;
! 1418: mpsafe = (vp->v_vflag & VV_MPSAFE);
! 1419: if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
! 1420: error = (VCALL(vp, VOFFSET(rump_vop_unlock), &a));
! 1421: if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
! 1422: return error;
! 1423: }
! 1424:
! 1425: const int rump_vop_bmap_vp_offsets[] = {
! 1426: VOPARG_OFFSETOF(struct rump_vop_bmap_args,a_vp),
! 1427: VDESC_NO_OFFSET
! 1428: };
! 1429: const struct vnodeop_desc rump_vop_bmap_desc = {
! 1430: RUMP_VOP_BMAP_DESCOFFSET,
! 1431: "rump_vop_bmap",
! 1432: 0,
! 1433: rump_vop_bmap_vp_offsets,
! 1434: VOPARG_OFFSETOF(struct rump_vop_bmap_args, a_vpp),
! 1435: VDESC_NO_OFFSET,
! 1436: VDESC_NO_OFFSET,
! 1437: NULL,
! 1438: };
! 1439: int
! 1440: RUMP_VOP_BMAP(struct vnode *vp,
! 1441: daddr_t bn,
! 1442: struct vnode **vpp,
! 1443: daddr_t *bnp,
! 1444: int *runp)
! 1445: {
! 1446: int error;
! 1447: bool mpsafe;
! 1448: struct rump_vop_bmap_args a;
! 1449: #ifdef VNODE_LOCKDEBUG
! 1450: #endif
! 1451: a.a_desc = VDESC(rump_vop_bmap);
! 1452: a.a_vp = vp;
! 1453: a.a_bn = bn;
! 1454: a.a_vpp = vpp;
! 1455: a.a_bnp = bnp;
! 1456: a.a_runp = runp;
! 1457: mpsafe = (vp->v_vflag & VV_MPSAFE);
! 1458: if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
! 1459: error = (VCALL(vp, VOFFSET(rump_vop_bmap), &a));
! 1460: if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
! 1461: return error;
! 1462: }
! 1463:
! 1464: const int rump_vop_strategy_vp_offsets[] = {
! 1465: VOPARG_OFFSETOF(struct rump_vop_strategy_args,a_vp),
! 1466: VDESC_NO_OFFSET
! 1467: };
! 1468: const struct vnodeop_desc rump_vop_strategy_desc = {
! 1469: RUMP_VOP_STRATEGY_DESCOFFSET,
! 1470: "rump_vop_strategy",
! 1471: 0,
! 1472: rump_vop_strategy_vp_offsets,
! 1473: VDESC_NO_OFFSET,
! 1474: VDESC_NO_OFFSET,
! 1475: VDESC_NO_OFFSET,
! 1476: NULL,
! 1477: };
! 1478: int
! 1479: RUMP_VOP_STRATEGY(struct vnode *vp,
! 1480: struct buf *bp)
! 1481: {
! 1482: int error;
! 1483: bool mpsafe;
! 1484: struct rump_vop_strategy_args a;
! 1485: #ifdef VNODE_LOCKDEBUG
! 1486: #endif
! 1487: a.a_desc = VDESC(rump_vop_strategy);
! 1488: a.a_vp = vp;
! 1489: a.a_bp = bp;
! 1490: mpsafe = (vp->v_vflag & VV_MPSAFE);
! 1491: if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
! 1492: error = (VCALL(vp, VOFFSET(rump_vop_strategy), &a));
! 1493: if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
! 1494: return error;
! 1495: }
! 1496:
! 1497: const int rump_vop_print_vp_offsets[] = {
! 1498: VOPARG_OFFSETOF(struct rump_vop_print_args,a_vp),
! 1499: VDESC_NO_OFFSET
! 1500: };
! 1501: const struct vnodeop_desc rump_vop_print_desc = {
! 1502: RUMP_VOP_PRINT_DESCOFFSET,
! 1503: "rump_vop_print",
! 1504: 0,
! 1505: rump_vop_print_vp_offsets,
! 1506: VDESC_NO_OFFSET,
! 1507: VDESC_NO_OFFSET,
! 1508: VDESC_NO_OFFSET,
! 1509: NULL,
! 1510: };
! 1511: int
! 1512: RUMP_VOP_PRINT(struct vnode *vp)
! 1513: {
! 1514: int error;
! 1515: bool mpsafe;
! 1516: struct rump_vop_print_args a;
! 1517: #ifdef VNODE_LOCKDEBUG
! 1518: #endif
! 1519: a.a_desc = VDESC(rump_vop_print);
! 1520: a.a_vp = vp;
! 1521: mpsafe = (vp->v_vflag & VV_MPSAFE);
! 1522: if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
! 1523: error = (VCALL(vp, VOFFSET(rump_vop_print), &a));
! 1524: if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
! 1525: return error;
! 1526: }
! 1527:
! 1528: const int rump_vop_islocked_vp_offsets[] = {
! 1529: VOPARG_OFFSETOF(struct rump_vop_islocked_args,a_vp),
! 1530: VDESC_NO_OFFSET
! 1531: };
! 1532: const struct vnodeop_desc rump_vop_islocked_desc = {
! 1533: RUMP_VOP_ISLOCKED_DESCOFFSET,
! 1534: "rump_vop_islocked",
! 1535: 0,
! 1536: rump_vop_islocked_vp_offsets,
! 1537: VDESC_NO_OFFSET,
! 1538: VDESC_NO_OFFSET,
! 1539: VDESC_NO_OFFSET,
! 1540: NULL,
! 1541: };
! 1542: int
! 1543: RUMP_VOP_ISLOCKED(struct vnode *vp)
! 1544: {
! 1545: int error;
! 1546: bool mpsafe;
! 1547: struct rump_vop_islocked_args a;
! 1548: #ifdef VNODE_LOCKDEBUG
! 1549: #endif
! 1550: a.a_desc = VDESC(rump_vop_islocked);
! 1551: a.a_vp = vp;
! 1552: mpsafe = (vp->v_vflag & VV_MPSAFE);
! 1553: if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
! 1554: error = (VCALL(vp, VOFFSET(rump_vop_islocked), &a));
! 1555: if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
! 1556: return error;
! 1557: }
! 1558:
! 1559: const int rump_vop_pathconf_vp_offsets[] = {
! 1560: VOPARG_OFFSETOF(struct rump_vop_pathconf_args,a_vp),
! 1561: VDESC_NO_OFFSET
! 1562: };
! 1563: const struct vnodeop_desc rump_vop_pathconf_desc = {
! 1564: RUMP_VOP_PATHCONF_DESCOFFSET,
! 1565: "rump_vop_pathconf",
! 1566: 0,
! 1567: rump_vop_pathconf_vp_offsets,
! 1568: VDESC_NO_OFFSET,
! 1569: VDESC_NO_OFFSET,
! 1570: VDESC_NO_OFFSET,
! 1571: NULL,
! 1572: };
! 1573: int
! 1574: RUMP_VOP_PATHCONF(struct vnode *vp,
! 1575: int name,
! 1576: register_t *retval)
! 1577: {
! 1578: int error;
! 1579: bool mpsafe;
! 1580: struct rump_vop_pathconf_args a;
! 1581: #ifdef VNODE_LOCKDEBUG
! 1582: int islocked_vp;
! 1583: #endif
! 1584: a.a_desc = VDESC(rump_vop_pathconf);
! 1585: a.a_vp = vp;
! 1586: #ifdef VNODE_LOCKDEBUG
! 1587: islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
! 1588: if (islocked_vp != 1)
! 1589: panic("rump_vop_pathconf: vp: locked %d, expected %d", islocked_vp, 1);
! 1590: #endif
! 1591: a.a_name = name;
! 1592: a.a_retval = retval;
! 1593: mpsafe = (vp->v_vflag & VV_MPSAFE);
! 1594: if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
! 1595: error = (VCALL(vp, VOFFSET(rump_vop_pathconf), &a));
! 1596: if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
! 1597: return error;
! 1598: }
! 1599:
! 1600: const int rump_vop_advlock_vp_offsets[] = {
! 1601: VOPARG_OFFSETOF(struct rump_vop_advlock_args,a_vp),
! 1602: VDESC_NO_OFFSET
! 1603: };
! 1604: const struct vnodeop_desc rump_vop_advlock_desc = {
! 1605: RUMP_VOP_ADVLOCK_DESCOFFSET,
! 1606: "rump_vop_advlock",
! 1607: 0,
! 1608: rump_vop_advlock_vp_offsets,
! 1609: VDESC_NO_OFFSET,
! 1610: VDESC_NO_OFFSET,
! 1611: VDESC_NO_OFFSET,
! 1612: NULL,
! 1613: };
! 1614: int
! 1615: RUMP_VOP_ADVLOCK(struct vnode *vp,
! 1616: void *id,
! 1617: int op,
! 1618: struct flock *fl,
! 1619: int flags)
! 1620: {
! 1621: int error;
! 1622: bool mpsafe;
! 1623: struct rump_vop_advlock_args a;
! 1624: #ifdef VNODE_LOCKDEBUG
! 1625: int islocked_vp;
! 1626: #endif
! 1627: a.a_desc = VDESC(rump_vop_advlock);
! 1628: a.a_vp = vp;
! 1629: #ifdef VNODE_LOCKDEBUG
! 1630: islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0;
! 1631: if (islocked_vp != 0)
! 1632: panic("rump_vop_advlock: vp: locked %d, expected %d", islocked_vp, 0);
! 1633: #endif
! 1634: a.a_id = id;
! 1635: a.a_op = op;
! 1636: a.a_fl = fl;
! 1637: a.a_flags = flags;
! 1638: mpsafe = (vp->v_vflag & VV_MPSAFE);
! 1639: if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
! 1640: error = (VCALL(vp, VOFFSET(rump_vop_advlock), &a));
! 1641: if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
! 1642: return error;
! 1643: }
! 1644:
! 1645: const int rump_vop_whiteout_vp_offsets[] = {
! 1646: VOPARG_OFFSETOF(struct rump_vop_whiteout_args,a_dvp),
! 1647: VDESC_NO_OFFSET
! 1648: };
! 1649: const struct vnodeop_desc rump_vop_whiteout_desc = {
! 1650: RUMP_VOP_WHITEOUT_DESCOFFSET,
! 1651: "rump_vop_whiteout",
! 1652: 0,
! 1653: rump_vop_whiteout_vp_offsets,
! 1654: VDESC_NO_OFFSET,
! 1655: VDESC_NO_OFFSET,
! 1656: VOPARG_OFFSETOF(struct rump_vop_whiteout_args, a_cnp),
! 1657: NULL,
! 1658: };
! 1659: int
! 1660: RUMP_VOP_WHITEOUT(struct vnode *dvp,
! 1661: struct componentname *cnp,
! 1662: int flags)
! 1663: {
! 1664: int error;
! 1665: bool mpsafe;
! 1666: struct rump_vop_whiteout_args a;
! 1667: #ifdef VNODE_LOCKDEBUG
! 1668: int islocked_dvp;
! 1669: #endif
! 1670: a.a_desc = VDESC(rump_vop_whiteout);
! 1671: a.a_dvp = dvp;
! 1672: #ifdef VNODE_LOCKDEBUG
! 1673: islocked_dvp = (dvp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1;
! 1674: if (islocked_dvp != 1)
! 1675: panic("rump_vop_whiteout: dvp: locked %d, expected %d", islocked_dvp, 1);
! 1676: #endif
! 1677: a.a_cnp = cnp;
! 1678: a.a_flags = flags;
! 1679: mpsafe = (dvp->v_vflag & VV_MPSAFE);
! 1680: if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
! 1681: error = (VCALL(dvp, VOFFSET(rump_vop_whiteout), &a));
! 1682: if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
! 1683: return error;
! 1684: }
! 1685:
! 1686: const int rump_vop_getpages_vp_offsets[] = {
! 1687: VOPARG_OFFSETOF(struct rump_vop_getpages_args,a_vp),
! 1688: VDESC_NO_OFFSET
! 1689: };
! 1690: const struct vnodeop_desc rump_vop_getpages_desc = {
! 1691: RUMP_VOP_GETPAGES_DESCOFFSET,
! 1692: "rump_vop_getpages",
! 1693: 0,
! 1694: rump_vop_getpages_vp_offsets,
! 1695: VDESC_NO_OFFSET,
! 1696: VDESC_NO_OFFSET,
! 1697: VDESC_NO_OFFSET,
! 1698: NULL,
! 1699: };
! 1700: int
! 1701: RUMP_VOP_GETPAGES(struct vnode *vp,
! 1702: off_t offset,
! 1703: struct vm_page **m,
! 1704: int *count,
! 1705: int centeridx,
! 1706: int access_type,
! 1707: int advice,
! 1708: int flags)
! 1709: {
! 1710: int error;
! 1711: bool mpsafe;
! 1712: struct rump_vop_getpages_args a;
! 1713: #ifdef VNODE_LOCKDEBUG
! 1714: #endif
! 1715: a.a_desc = VDESC(rump_vop_getpages);
! 1716: a.a_vp = vp;
! 1717: a.a_offset = offset;
! 1718: a.a_m = m;
! 1719: a.a_count = count;
! 1720: a.a_centeridx = centeridx;
! 1721: a.a_access_type = access_type;
! 1722: a.a_advice = advice;
! 1723: a.a_flags = flags;
! 1724: mpsafe = (vp->v_vflag & VV_MPSAFE);
! 1725: if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
! 1726: error = (VCALL(vp, VOFFSET(rump_vop_getpages), &a));
! 1727: if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
! 1728: return error;
! 1729: }
! 1730:
! 1731: const int rump_vop_putpages_vp_offsets[] = {
! 1732: VOPARG_OFFSETOF(struct rump_vop_putpages_args,a_vp),
! 1733: VDESC_NO_OFFSET
! 1734: };
! 1735: const struct vnodeop_desc rump_vop_putpages_desc = {
! 1736: RUMP_VOP_PUTPAGES_DESCOFFSET,
! 1737: "rump_vop_putpages",
! 1738: 0,
! 1739: rump_vop_putpages_vp_offsets,
! 1740: VDESC_NO_OFFSET,
! 1741: VDESC_NO_OFFSET,
! 1742: VDESC_NO_OFFSET,
! 1743: NULL,
! 1744: };
! 1745: int
! 1746: RUMP_VOP_PUTPAGES(struct vnode *vp,
! 1747: off_t offlo,
! 1748: off_t offhi,
! 1749: int flags)
! 1750: {
! 1751: int error;
! 1752: bool mpsafe;
! 1753: struct rump_vop_putpages_args a;
! 1754: #ifdef VNODE_LOCKDEBUG
! 1755: #endif
! 1756: a.a_desc = VDESC(rump_vop_putpages);
! 1757: a.a_vp = vp;
! 1758: a.a_offlo = offlo;
! 1759: a.a_offhi = offhi;
! 1760: a.a_flags = flags;
! 1761: mpsafe = (vp->v_vflag & VV_MPSAFE);
! 1762: if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
! 1763: error = (VCALL(vp, VOFFSET(rump_vop_putpages), &a));
! 1764: if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
! 1765: return error;
! 1766: }
! 1767:
! 1768: const int rump_vop_closeextattr_vp_offsets[] = {
! 1769: VOPARG_OFFSETOF(struct rump_vop_closeextattr_args,a_vp),
! 1770: VDESC_NO_OFFSET
! 1771: };
! 1772: const struct vnodeop_desc rump_vop_closeextattr_desc = {
! 1773: RUMP_VOP_CLOSEEXTATTR_DESCOFFSET,
! 1774: "rump_vop_closeextattr",
! 1775: 0,
! 1776: rump_vop_closeextattr_vp_offsets,
! 1777: VDESC_NO_OFFSET,
! 1778: VOPARG_OFFSETOF(struct rump_vop_closeextattr_args, a_cred),
! 1779: VDESC_NO_OFFSET,
! 1780: NULL,
! 1781: };
! 1782: int
! 1783: RUMP_VOP_CLOSEEXTATTR(struct vnode *vp,
! 1784: int commit,
! 1785: kauth_cred_t cred)
! 1786: {
! 1787: int error;
! 1788: bool mpsafe;
! 1789: struct rump_vop_closeextattr_args a;
! 1790: #ifdef VNODE_LOCKDEBUG
! 1791: int islocked_vp;
! 1792: #endif
! 1793: a.a_desc = VDESC(rump_vop_closeextattr);
! 1794: a.a_vp = vp;
! 1795: #ifdef VNODE_LOCKDEBUG
! 1796: islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
! 1797: if (islocked_vp != 1)
! 1798: panic("rump_vop_closeextattr: vp: locked %d, expected %d", islocked_vp, 1);
! 1799: #endif
! 1800: a.a_commit = commit;
! 1801: a.a_cred = cred;
! 1802: mpsafe = (vp->v_vflag & VV_MPSAFE);
! 1803: if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
! 1804: error = (VCALL(vp, VOFFSET(rump_vop_closeextattr), &a));
! 1805: if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
! 1806: return error;
! 1807: }
! 1808:
! 1809: const int rump_vop_getextattr_vp_offsets[] = {
! 1810: VOPARG_OFFSETOF(struct rump_vop_getextattr_args,a_vp),
! 1811: VDESC_NO_OFFSET
! 1812: };
! 1813: const struct vnodeop_desc rump_vop_getextattr_desc = {
! 1814: RUMP_VOP_GETEXTATTR_DESCOFFSET,
! 1815: "rump_vop_getextattr",
! 1816: 0,
! 1817: rump_vop_getextattr_vp_offsets,
! 1818: VDESC_NO_OFFSET,
! 1819: VOPARG_OFFSETOF(struct rump_vop_getextattr_args, a_cred),
! 1820: VDESC_NO_OFFSET,
! 1821: NULL,
! 1822: };
! 1823: int
! 1824: RUMP_VOP_GETEXTATTR(struct vnode *vp,
! 1825: int attrnamespace,
! 1826: const char *name,
! 1827: struct uio *uio,
! 1828: size_t *size,
! 1829: kauth_cred_t cred)
! 1830: {
! 1831: int error;
! 1832: bool mpsafe;
! 1833: struct rump_vop_getextattr_args a;
! 1834: #ifdef VNODE_LOCKDEBUG
! 1835: int islocked_vp;
! 1836: #endif
! 1837: a.a_desc = VDESC(rump_vop_getextattr);
! 1838: a.a_vp = vp;
! 1839: #ifdef VNODE_LOCKDEBUG
! 1840: islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
! 1841: if (islocked_vp != 1)
! 1842: panic("rump_vop_getextattr: vp: locked %d, expected %d", islocked_vp, 1);
! 1843: #endif
! 1844: a.a_attrnamespace = attrnamespace;
! 1845: a.a_name = name;
! 1846: a.a_uio = uio;
! 1847: a.a_size = size;
! 1848: a.a_cred = cred;
! 1849: mpsafe = (vp->v_vflag & VV_MPSAFE);
! 1850: if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
! 1851: error = (VCALL(vp, VOFFSET(rump_vop_getextattr), &a));
! 1852: if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
! 1853: return error;
! 1854: }
! 1855:
! 1856: const int rump_vop_listextattr_vp_offsets[] = {
! 1857: VOPARG_OFFSETOF(struct rump_vop_listextattr_args,a_vp),
! 1858: VDESC_NO_OFFSET
! 1859: };
! 1860: const struct vnodeop_desc rump_vop_listextattr_desc = {
! 1861: RUMP_VOP_LISTEXTATTR_DESCOFFSET,
! 1862: "rump_vop_listextattr",
! 1863: 0,
! 1864: rump_vop_listextattr_vp_offsets,
! 1865: VDESC_NO_OFFSET,
! 1866: VOPARG_OFFSETOF(struct rump_vop_listextattr_args, a_cred),
! 1867: VDESC_NO_OFFSET,
! 1868: NULL,
! 1869: };
! 1870: int
! 1871: RUMP_VOP_LISTEXTATTR(struct vnode *vp,
! 1872: int attrnamespace,
! 1873: struct uio *uio,
! 1874: size_t *size,
! 1875: kauth_cred_t cred)
! 1876: {
! 1877: int error;
! 1878: bool mpsafe;
! 1879: struct rump_vop_listextattr_args a;
! 1880: #ifdef VNODE_LOCKDEBUG
! 1881: int islocked_vp;
! 1882: #endif
! 1883: a.a_desc = VDESC(rump_vop_listextattr);
! 1884: a.a_vp = vp;
! 1885: #ifdef VNODE_LOCKDEBUG
! 1886: islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
! 1887: if (islocked_vp != 1)
! 1888: panic("rump_vop_listextattr: vp: locked %d, expected %d", islocked_vp, 1);
! 1889: #endif
! 1890: a.a_attrnamespace = attrnamespace;
! 1891: a.a_uio = uio;
! 1892: a.a_size = size;
! 1893: a.a_cred = cred;
! 1894: mpsafe = (vp->v_vflag & VV_MPSAFE);
! 1895: if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
! 1896: error = (VCALL(vp, VOFFSET(rump_vop_listextattr), &a));
! 1897: if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
! 1898: return error;
! 1899: }
! 1900:
! 1901: const int rump_vop_openextattr_vp_offsets[] = {
! 1902: VOPARG_OFFSETOF(struct rump_vop_openextattr_args,a_vp),
! 1903: VDESC_NO_OFFSET
! 1904: };
! 1905: const struct vnodeop_desc rump_vop_openextattr_desc = {
! 1906: RUMP_VOP_OPENEXTATTR_DESCOFFSET,
! 1907: "rump_vop_openextattr",
! 1908: 0,
! 1909: rump_vop_openextattr_vp_offsets,
! 1910: VDESC_NO_OFFSET,
! 1911: VOPARG_OFFSETOF(struct rump_vop_openextattr_args, a_cred),
! 1912: VDESC_NO_OFFSET,
! 1913: NULL,
! 1914: };
! 1915: int
! 1916: RUMP_VOP_OPENEXTATTR(struct vnode *vp,
! 1917: kauth_cred_t cred)
! 1918: {
! 1919: int error;
! 1920: bool mpsafe;
! 1921: struct rump_vop_openextattr_args a;
! 1922: #ifdef VNODE_LOCKDEBUG
! 1923: int islocked_vp;
! 1924: #endif
! 1925: a.a_desc = VDESC(rump_vop_openextattr);
! 1926: a.a_vp = vp;
! 1927: #ifdef VNODE_LOCKDEBUG
! 1928: islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
! 1929: if (islocked_vp != 1)
! 1930: panic("rump_vop_openextattr: vp: locked %d, expected %d", islocked_vp, 1);
! 1931: #endif
! 1932: a.a_cred = cred;
! 1933: mpsafe = (vp->v_vflag & VV_MPSAFE);
! 1934: if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
! 1935: error = (VCALL(vp, VOFFSET(rump_vop_openextattr), &a));
! 1936: if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
! 1937: return error;
! 1938: }
! 1939:
! 1940: const int rump_vop_deleteextattr_vp_offsets[] = {
! 1941: VOPARG_OFFSETOF(struct rump_vop_deleteextattr_args,a_vp),
! 1942: VDESC_NO_OFFSET
! 1943: };
! 1944: const struct vnodeop_desc rump_vop_deleteextattr_desc = {
! 1945: RUMP_VOP_DELETEEXTATTR_DESCOFFSET,
! 1946: "rump_vop_deleteextattr",
! 1947: 0,
! 1948: rump_vop_deleteextattr_vp_offsets,
! 1949: VDESC_NO_OFFSET,
! 1950: VOPARG_OFFSETOF(struct rump_vop_deleteextattr_args, a_cred),
! 1951: VDESC_NO_OFFSET,
! 1952: NULL,
! 1953: };
! 1954: int
! 1955: RUMP_VOP_DELETEEXTATTR(struct vnode *vp,
! 1956: int attrnamespace,
! 1957: const char *name,
! 1958: kauth_cred_t cred)
! 1959: {
! 1960: int error;
! 1961: bool mpsafe;
! 1962: struct rump_vop_deleteextattr_args a;
! 1963: #ifdef VNODE_LOCKDEBUG
! 1964: int islocked_vp;
! 1965: #endif
! 1966: a.a_desc = VDESC(rump_vop_deleteextattr);
! 1967: a.a_vp = vp;
! 1968: #ifdef VNODE_LOCKDEBUG
! 1969: islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
! 1970: if (islocked_vp != 1)
! 1971: panic("rump_vop_deleteextattr: vp: locked %d, expected %d", islocked_vp, 1);
! 1972: #endif
! 1973: a.a_attrnamespace = attrnamespace;
! 1974: a.a_name = name;
! 1975: a.a_cred = cred;
! 1976: mpsafe = (vp->v_vflag & VV_MPSAFE);
! 1977: if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
! 1978: error = (VCALL(vp, VOFFSET(rump_vop_deleteextattr), &a));
! 1979: if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
! 1980: return error;
! 1981: }
! 1982:
! 1983: const int rump_vop_setextattr_vp_offsets[] = {
! 1984: VOPARG_OFFSETOF(struct rump_vop_setextattr_args,a_vp),
! 1985: VDESC_NO_OFFSET
! 1986: };
! 1987: const struct vnodeop_desc rump_vop_setextattr_desc = {
! 1988: RUMP_VOP_SETEXTATTR_DESCOFFSET,
! 1989: "rump_vop_setextattr",
! 1990: 0,
! 1991: rump_vop_setextattr_vp_offsets,
! 1992: VDESC_NO_OFFSET,
! 1993: VOPARG_OFFSETOF(struct rump_vop_setextattr_args, a_cred),
! 1994: VDESC_NO_OFFSET,
! 1995: NULL,
! 1996: };
! 1997: int
! 1998: RUMP_VOP_SETEXTATTR(struct vnode *vp,
! 1999: int attrnamespace,
! 2000: const char *name,
! 2001: struct uio *uio,
! 2002: kauth_cred_t cred)
! 2003: {
! 2004: int error;
! 2005: bool mpsafe;
! 2006: struct rump_vop_setextattr_args a;
! 2007: #ifdef VNODE_LOCKDEBUG
! 2008: int islocked_vp;
! 2009: #endif
! 2010: a.a_desc = VDESC(rump_vop_setextattr);
! 2011: a.a_vp = vp;
! 2012: #ifdef VNODE_LOCKDEBUG
! 2013: islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
! 2014: if (islocked_vp != 1)
! 2015: panic("rump_vop_setextattr: vp: locked %d, expected %d", islocked_vp, 1);
! 2016: #endif
! 2017: a.a_attrnamespace = attrnamespace;
! 2018: a.a_name = name;
! 2019: a.a_uio = uio;
! 2020: a.a_cred = cred;
! 2021: mpsafe = (vp->v_vflag & VV_MPSAFE);
! 2022: if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
! 2023: error = (VCALL(vp, VOFFSET(rump_vop_setextattr), &a));
! 2024: if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
! 2025: return error;
! 2026: }
! 2027:
! 2028: /* End of special cases. */
! 2029:
! 2030: const struct vnodeop_desc * const rump_vfs_op_descs[] = {
! 2031: &rump_vop_default_desc, /* MUST BE FIRST */
! 2032: &rump_vop_bwrite_desc, /* XXX: SPECIAL CASE */
! 2033:
! 2034: &rump_vop_lookup_desc,
! 2035: &rump_vop_create_desc,
! 2036: &rump_vop_mknod_desc,
! 2037: &rump_vop_open_desc,
! 2038: &rump_vop_close_desc,
! 2039: &rump_vop_access_desc,
! 2040: &rump_vop_getattr_desc,
! 2041: &rump_vop_setattr_desc,
! 2042: &rump_vop_read_desc,
! 2043: &rump_vop_write_desc,
! 2044: &rump_vop_ioctl_desc,
! 2045: &rump_vop_fcntl_desc,
! 2046: &rump_vop_poll_desc,
! 2047: &rump_vop_kqfilter_desc,
! 2048: &rump_vop_revoke_desc,
! 2049: &rump_vop_mmap_desc,
! 2050: &rump_vop_fsync_desc,
! 2051: &rump_vop_seek_desc,
! 2052: &rump_vop_remove_desc,
! 2053: &rump_vop_link_desc,
! 2054: &rump_vop_rename_desc,
! 2055: &rump_vop_mkdir_desc,
! 2056: &rump_vop_rmdir_desc,
! 2057: &rump_vop_symlink_desc,
! 2058: &rump_vop_readdir_desc,
! 2059: &rump_vop_readlink_desc,
! 2060: &rump_vop_abortop_desc,
! 2061: &rump_vop_inactive_desc,
! 2062: &rump_vop_reclaim_desc,
! 2063: &rump_vop_lock_desc,
! 2064: &rump_vop_unlock_desc,
! 2065: &rump_vop_bmap_desc,
! 2066: &rump_vop_strategy_desc,
! 2067: &rump_vop_print_desc,
! 2068: &rump_vop_islocked_desc,
! 2069: &rump_vop_pathconf_desc,
! 2070: &rump_vop_advlock_desc,
! 2071: &rump_vop_whiteout_desc,
! 2072: &rump_vop_getpages_desc,
! 2073: &rump_vop_putpages_desc,
! 2074: &rump_vop_closeextattr_desc,
! 2075: &rump_vop_getextattr_desc,
! 2076: &rump_vop_listextattr_desc,
! 2077: &rump_vop_openextattr_desc,
! 2078: &rump_vop_deleteextattr_desc,
! 2079: &rump_vop_setextattr_desc,
! 2080: NULL
! 2081: };
! 2082:
CVSweb <webmaster@jp.NetBSD.org>
![[BACK]](/icons/back.gif){kind=icon}
Return to rumpvnode_if.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [cvs.NetBSD.org] / src / sys / rump / librump / rumpvfs