Annotation of sys/xfs/xfs_vnodeops-common.c, Revision 1.1
1.1 ! nbrk 1: /*
! 2: * Copyright (c) 1995 - 2002 Kungliga Tekniska Högskolan
! 3: * (Royal Institute of Technology, Stockholm, Sweden).
! 4: * All rights reserved.
! 5: *
! 6: * Redistribution and use in source and binary forms, with or without
! 7: * modification, are permitted provided that the following conditions
! 8: * are met:
! 9: *
! 10: * 1. Redistributions of source code must retain the above copyright
! 11: * notice, this list of conditions and the following disclaimer.
! 12: *
! 13: * 2. Redistributions in binary form must reproduce the above copyright
! 14: * notice, this list of conditions and the following disclaimer in the
! 15: * documentation and/or other materials provided with the distribution.
! 16: *
! 17: * 3. Neither the name of the Institute nor the names of its contributors
! 18: * may be used to endorse or promote products derived from this software
! 19: * without specific prior written permission.
! 20: *
! 21: * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
! 22: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 23: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 24: * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
! 25: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 26: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 27: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 28: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 29: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 30: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 31: * SUCH DAMAGE.
! 32: */
! 33:
! 34: /*
! 35: * NNPFS operations.
! 36: */
! 37:
! 38: #include <xfs/xfs_locl.h>
! 39: #include <xfs/xfs_message.h>
! 40: #include <xfs/xfs_common.h>
! 41: #include <xfs/xfs_fs.h>
! 42: #include <xfs/xfs_dev.h>
! 43: #include <xfs/xfs_deb.h>
! 44: #include <xfs/xfs_syscalls.h>
! 45: #include <xfs/xfs_vnodeops.h>
! 46:
! 47: RCSID("$arla: xfs_vnodeops-common.c,v 1.94 2003/01/27 11:58:50 lha Exp $");
! 48:
! 49: static void
! 50: xfs_handle_stale(struct xfs_node *xn)
! 51: {
! 52: #if __APPLE__
! 53: struct vnode *vp = XNODE_TO_VNODE(xn);
! 54: #endif
! 55:
! 56: if ((xn->flags & NNPFS_STALE) == 0)
! 57: return;
! 58:
! 59: #if __APPLE__
! 60: if (UBCISVALID(vp) && !ubc_isinuse(vp, 1)) {
! 61: xn->flags &= ~NNPFS_STALE;
! 62: ubc_setsize(vp, 0);
! 63: NNPFS_TOKEN_CLEAR(xn, ~0,
! 64: NNPFS_OPEN_MASK | NNPFS_ATTR_MASK |
! 65: NNPFS_DATA_MASK | NNPFS_LOCK_MASK);
! 66: }
! 67: #endif
! 68: }
! 69:
! 70: int
! 71: xfs_open_valid(struct vnode *vp, struct ucred *cred, d_thread_t *p,
! 72: u_int tok)
! 73: {
! 74: struct xfs *xfsp = NNPFS_FROM_VNODE(vp);
! 75: struct xfs_node *xn = VNODE_TO_XNODE(vp);
! 76: int error = 0;
! 77:
! 78: NNPFSDEB(XDEBVFOPS, ("xfs_open_valid\n"));
! 79:
! 80: xfs_handle_stale(xn);
! 81:
! 82: do {
! 83: if (!NNPFS_TOKEN_GOT(xn, tok)) {
! 84: struct xfs_message_open msg;
! 85:
! 86: msg.header.opcode = NNPFS_MSG_OPEN;
! 87: msg.cred.uid = cred->cr_uid;
! 88: msg.cred.pag = xfs_get_pag(cred);
! 89: msg.handle = xn->handle;
! 90: msg.tokens = tok;
! 91:
! 92: error = xfs_message_rpc(xfsp->fd, &msg.header, sizeof(msg), p);
! 93:
! 94: if (error == 0)
! 95: error = ((struct xfs_message_wakeup *) & msg)->error;
! 96: } else {
! 97: goto done;
! 98: }
! 99: } while (error == 0);
! 100:
! 101: done:
! 102: NNPFSDEB(XDEBVFOPS, ("xfs_open_valid: error = %d\n", error));
! 103:
! 104: return error;
! 105: }
! 106:
! 107: int
! 108: xfs_attr_valid(struct vnode *vp, struct ucred *cred, d_thread_t *p,
! 109: u_int tok)
! 110: {
! 111: struct xfs *xfsp = NNPFS_FROM_VNODE(vp);
! 112: struct xfs_node *xn = VNODE_TO_XNODE(vp);
! 113: int error = 0;
! 114: xfs_pag_t pag = xfs_get_pag(cred);
! 115:
! 116: do {
! 117: if (!NNPFS_TOKEN_GOT(xn, tok) || !xfs_has_pag(xn, pag)) {
! 118: struct xfs_message_getattr msg;
! 119:
! 120: msg.header.opcode = NNPFS_MSG_GETATTR;
! 121: msg.cred.uid = cred->cr_uid;
! 122: msg.cred.pag = pag;
! 123: msg.handle = xn->handle;
! 124: error = xfs_message_rpc(xfsp->fd, &msg.header, sizeof(msg), p);
! 125: if (error == 0)
! 126: error = ((struct xfs_message_wakeup *) & msg)->error;
! 127: } else {
! 128: goto done;
! 129: }
! 130: } while (error == 0);
! 131:
! 132: done:
! 133: return error;
! 134: }
! 135:
! 136: int
! 137: xfs_data_valid(struct vnode *vp, struct ucred *cred, d_thread_t *p,
! 138: u_int tok, uint32_t want_offset)
! 139: {
! 140: struct xfs *xfsp = NNPFS_FROM_VNODE(vp);
! 141: struct xfs_node *xn = VNODE_TO_XNODE(vp);
! 142: int error = 0;
! 143: uint32_t offset;
! 144: struct xfs_message_getdata msg;
! 145:
! 146: do {
! 147: offset = want_offset;
! 148: if (NNPFS_TOKEN_GOT(xn, tok|NNPFS_ATTR_R) && offset > xn->attr.va_size) {
! 149: offset = xn->attr.va_size;
! 150: }
! 151:
! 152: NNPFSDEB(XDEBVNOPS, ("xfs_data_valid: offset: want %ld has %ld, "
! 153: "tokens: want %lx has %lx length: %ld\n",
! 154: (long) offset, (long) xn->offset,
! 155: (long) tok, (long) xn->tokens,
! 156: (long) xn->attr.va_size));
! 157:
! 158: if (NNPFS_TOKEN_GOT(xn, tok)) {
! 159: if (offset <= xn->offset || xn->attr.va_type == VDIR) {
! 160: break;
! 161: }
! 162: }
! 163:
! 164: msg.header.opcode = NNPFS_MSG_GETDATA;
! 165: msg.cred.uid = cred->cr_uid;
! 166: msg.cred.pag = xfs_get_pag(cred);
! 167: msg.handle = xn->handle;
! 168: msg.tokens = tok;
! 169: msg.offset = offset;
! 170:
! 171: error = xfs_message_rpc(xfsp->fd, &msg.header, sizeof(msg), p);
! 172:
! 173: if (error == 0)
! 174: error = ((struct xfs_message_wakeup *) & msg)->error;
! 175:
! 176: } while (error == 0);
! 177:
! 178: return error;
! 179: }
! 180:
! 181: int
! 182: xfs_open_common(struct vnode *vp,
! 183: int mode,
! 184: struct ucred *cred,
! 185: d_thread_t *p)
! 186: {
! 187: struct xfs_node *xn = VNODE_TO_XNODE(vp);
! 188: int ret;
! 189:
! 190: NNPFSDEB(XDEBVNOPS, ("xfs_open\n"));
! 191:
! 192: if (mode & FWRITE) {
! 193: ret = xfs_open_valid(vp, cred, p, NNPFS_OPEN_NW);
! 194: } else {
! 195: ret = xfs_open_valid(vp, cred, p, NNPFS_OPEN_NR);
! 196: }
! 197:
! 198: /* always update the read cred */
! 199:
! 200: if (mode & FWRITE)
! 201: xfs_update_write_cred(xn, cred);
! 202: xfs_update_read_cred(xn, cred);
! 203:
! 204: return ret;
! 205: }
! 206:
! 207: static int
! 208: do_fsync(struct xfs *xfsp,
! 209: struct xfs_node *xn,
! 210: struct ucred *cred,
! 211: d_thread_t *p,
! 212: u_int flag)
! 213: {
! 214: int error;
! 215: struct xfs_message_putdata msg;
! 216:
! 217: msg.header.opcode = NNPFS_MSG_PUTDATA;
! 218: if (cred != NOCRED) {
! 219: msg.cred.uid = cred->cr_uid;
! 220: msg.cred.pag = xfs_get_pag(cred);
! 221: } else {
! 222: msg.cred.uid = 0;
! 223: msg.cred.pag = NNPFS_ANONYMOUSID;
! 224: }
! 225: msg.handle = xn->handle;
! 226: vattr2xfs_attr(&xn->attr, &msg.attr);
! 227: msg.flag = flag;
! 228:
! 229: error = xfs_message_rpc(xfsp->fd, &msg.header, sizeof(msg), p);
! 230:
! 231: if (error == 0)
! 232: error = ((struct xfs_message_wakeup *) & msg)->error;
! 233:
! 234: if (error == 0)
! 235: xn->flags &= ~NNPFS_DATA_DIRTY;
! 236:
! 237: return error;
! 238: }
! 239:
! 240: int
! 241: xfs_fsync_common(struct vnode *vp, struct ucred *cred,
! 242: int waitfor, d_thread_t *proc)
! 243: {
! 244: struct xfs *xfsp = NNPFS_FROM_VNODE(vp);
! 245: struct xfs_node *xn = VNODE_TO_XNODE(vp);
! 246: int error = 0;
! 247:
! 248: NNPFSDEB(XDEBVNOPS, ("xfs_fsync: %lx\n", (unsigned long)vp));
! 249:
! 250: /*
! 251: * It seems that fsync is sometimes called after reclaiming a node.
! 252: * In that case we just look happy.
! 253: */
! 254:
! 255: if (xn == NULL) {
! 256: printf("NNPFS PANIC WARNING! xfs_fsync called after reclaiming!\n");
! 257: return 0;
! 258: }
! 259:
! 260: xfs_pushdirty(vp, cred, proc);
! 261:
! 262: if (xn->flags & NNPFS_DATA_DIRTY) {
! 263: #ifdef FSYNC_RECLAIM
! 264: /* writing back the data from this vnode failed */
! 265: if (waitfor & FSYNC_RECLAIM) {
! 266: printf("xfs_fsync: data lost, failed to write back\n");
! 267: xn->flags &= ~NNPFS_DATA_DIRTY;
! 268: return 0;
! 269: }
! 270: #endif
! 271: error = do_fsync(xfsp, xn, cred, proc, NNPFS_WRITE | NNPFS_FSYNC);
! 272: }
! 273:
! 274: return error;
! 275: }
! 276:
! 277: int
! 278: xfs_close_common(struct vnode *vp, int fflag,
! 279: d_thread_t *proc, struct ucred *cred)
! 280: {
! 281: struct xfs *xfsp = NNPFS_FROM_VNODE(vp);
! 282: struct xfs_node *xn = VNODE_TO_XNODE(vp);
! 283: int error = 0;
! 284:
! 285: NNPFSDEB(XDEBVNOPS,
! 286: ("xfs_close cred = %lx, fflag = %x, xn->flags = %x\n",
! 287: (unsigned long)cred, fflag, xn->flags));
! 288:
! 289: if (vp->v_type == VREG)
! 290: xfs_pushdirty(vp, cred, proc);
! 291:
! 292: if (fflag & FWRITE && xn->flags & NNPFS_DATA_DIRTY)
! 293: error = do_fsync(xfsp, xn, cred, proc, NNPFS_WRITE);
! 294:
! 295: return error;
! 296: }
! 297:
! 298: size_t
! 299: xfs_uio_end_length (struct uio *uio)
! 300: {
! 301: #ifdef DIAGNOSTIC
! 302: size_t sz = 0;
! 303: int i;
! 304:
! 305: for (i = 0; i < uio->uio_iovcnt; i++)
! 306: sz += uio->uio_iov[i].iov_len;
! 307: if (sz != uio->uio_resid)
! 308: panic("xfs_uio_end_length");
! 309: #endif
! 310: return uio->uio_offset + uio->uio_resid;
! 311: }
! 312:
! 313:
! 314: int
! 315: xfs_read_common(struct vnode *vp, struct uio *uio, int ioflag,
! 316: struct ucred *cred)
! 317: {
! 318: int error = 0;
! 319: int i;
! 320:
! 321: NNPFSDEB(XDEBVNOPS, ("xfs_read\n"));
! 322:
! 323: xfs_update_read_cred(VNODE_TO_XNODE(vp), cred);
! 324:
! 325: #ifdef HAVE_FREEBSD_THREAD
! 326: error = xfs_data_valid(vp, cred, xfs_uio_to_thread(uio), NNPFS_DATA_R,
! 327: xfs_uio_end_length(uio));
! 328: #else
! 329: error = xfs_data_valid(vp, cred, xfs_uio_to_proc(uio), NNPFS_DATA_R,
! 330: xfs_uio_end_length(uio));
! 331: #endif
! 332:
! 333: NNPFSDEB(XDEBVNOPS, ("xfs_read: iovcnt: %d\n", uio->uio_iovcnt));
! 334: for (i = 0; i < uio->uio_iovcnt; i++)
! 335: NNPFSDEB(XDEBVNOPS, (" base: %lx len: %lu\n",
! 336: (unsigned long)uio->uio_iov[i].iov_base,
! 337: (unsigned long)uio->uio_iov[i].iov_len));
! 338:
! 339: if (error == 0) {
! 340: struct vnode *t = DATA_FROM_VNODE(vp);
! 341:
! 342: #ifdef HAVE_FREEBSD_THREAD
! 343: xfs_vfs_readlock(t, xfs_uio_to_thread(uio));
! 344: xfs_vop_read(t, uio, ioflag, cred, error);
! 345: xfs_vfs_unlock(t, xfs_uio_to_thread(uio));
! 346: #else
! 347: xfs_vfs_readlock(t, xfs_uio_to_proc(uio));
! 348: xfs_vop_read(t, uio, ioflag, cred, error);
! 349: xfs_vfs_unlock(t, xfs_uio_to_proc(uio));
! 350: #endif
! 351: }
! 352:
! 353: NNPFSDEB(XDEBVNOPS, ("xfs_read offset: %lu resid: %lu\n",
! 354: (unsigned long)uio->uio_offset,
! 355: (unsigned long)uio->uio_resid));
! 356: NNPFSDEB(XDEBVNOPS, ("xfs_read error: %d\n", error));
! 357:
! 358: return error;
! 359: }
! 360:
! 361: int
! 362: xfs_write_common(struct vnode *vp, struct uio *uiop, int ioflag,
! 363: struct ucred *cred)
! 364: {
! 365: struct xfs_node *xn = VNODE_TO_XNODE(vp);
! 366: int error = 0;
! 367:
! 368: NNPFSDEB(XDEBVNOPS, ("xfs_write\n"));
! 369:
! 370: xfs_update_write_cred(xn, cred);
! 371:
! 372: #ifdef HAVE_FREEBSD_THREAD
! 373: error = xfs_data_valid(vp, cred, xfs_uio_to_thread(uiop), NNPFS_DATA_W,
! 374: VNODE_TO_XNODE(vp)->attr.va_size);
! 375: #else
! 376: error = xfs_data_valid(vp, cred, xfs_uio_to_proc(uiop), NNPFS_DATA_W,
! 377: VNODE_TO_XNODE(vp)->attr.va_size);
! 378: #endif
! 379:
! 380: if (error == 0) {
! 381: struct vnode *t = DATA_FROM_XNODE(xn);
! 382: struct vattr sub_attr;
! 383: int error2 = 0;
! 384:
! 385: #ifdef HAVE_FREEBSD_THREAD
! 386: xfs_vfs_writelock(t, xfs_uio_to_thread(uiop));
! 387: xfs_vop_write(t, uiop, ioflag, cred, error);
! 388: VNODE_TO_XNODE(vp)->flags |= NNPFS_DATA_DIRTY;
! 389: xfs_vop_getattr(t, &sub_attr, cred, xfs_uio_to_thread(uiop), error2);
! 390: #else
! 391: xfs_vfs_writelock(t, xfs_uio_to_proc(uiop));
! 392: xfs_vop_write(t, uiop, ioflag, cred, error);
! 393: VNODE_TO_XNODE(vp)->flags |= NNPFS_DATA_DIRTY;
! 394: xfs_vop_getattr(t, &sub_attr, cred, xfs_uio_to_proc(uiop), error2);
! 395: #endif
! 396:
! 397: if (error2 == 0) {
! 398: xn->attr.va_size = sub_attr.va_size;
! 399: xn->attr.va_bytes = sub_attr.va_size;
! 400: xn->attr.va_mtime = sub_attr.va_mtime;
! 401: xfs_set_vp_size(vp, sub_attr.va_size);
! 402: xn->offset = sub_attr.va_size;
! 403: }
! 404: #ifdef HAVE_FREEBSD_THREAD
! 405: xfs_vfs_unlock(t, xfs_uio_to_thread(uiop));
! 406: #else
! 407: xfs_vfs_unlock(t, xfs_uio_to_proc(uiop));
! 408: #endif
! 409: }
! 410:
! 411: return error;
! 412: }
! 413:
! 414: int
! 415: xfs_getattr_common(struct vnode *vp, struct vattr *vap,
! 416: struct ucred *cred, d_thread_t *p)
! 417: {
! 418: int error = 0;
! 419:
! 420: struct xfs_node *xn = VNODE_TO_XNODE(vp);
! 421:
! 422: NNPFSDEB(XDEBVNOPS, ("xfs_getattr\n"));
! 423:
! 424: error = xfs_attr_valid(vp, cred, p, NNPFS_ATTR_R);
! 425: if (error == 0)
! 426: *vap = xn->attr;
! 427: return error;
! 428: }
! 429:
! 430: int
! 431: xfs_setattr_common(struct vnode *vp, struct vattr *vap,
! 432: struct ucred *cred, d_thread_t *p)
! 433: {
! 434: struct xfs *xfsp = NNPFS_FROM_VNODE(vp);
! 435: struct xfs_node *xn = VNODE_TO_XNODE(vp);
! 436: int error = 0;
! 437:
! 438: NNPFSDEB(XDEBVNOPS, ("xfs_setattr\n"));
! 439:
! 440: #define CHECK_NNPFSATTR(A, cast) (vap->A == cast VNOVAL || vap->A == xn->attr.A)
! 441: if (CHECK_NNPFSATTR(va_mode,(mode_t)) &&
! 442: CHECK_NNPFSATTR(va_nlink,(short)) &&
! 443: CHECK_NNPFSATTR(va_size,(va_size_t)) &&
! 444: CHECK_NNPFSATTR(va_uid,(uid_t)) &&
! 445: CHECK_NNPFSATTR(va_gid,(gid_t)) &&
! 446: CHECK_NNPFSATTR(va_mtime.tv_sec,(unsigned int)) &&
! 447: CHECK_NNPFSATTR(va_fileid,(long)) &&
! 448: CHECK_NNPFSATTR(va_type,(enum vtype)))
! 449: return 0; /* Nothing to do */
! 450: #undef CHECK_NNPFSATTR
! 451:
! 452: if (NNPFS_TOKEN_GOT(xn, NNPFS_ATTR_W)) {
! 453: /* Update attributes and mark them dirty. */
! 454: VNODE_TO_XNODE(vp)->flags |= NNPFS_ATTR_DIRTY;
! 455: error = EINVAL; /* XXX not yet implemented */
! 456: goto done;
! 457: } else {
! 458: struct xfs_message_putattr msg;
! 459:
! 460: msg.header.opcode = NNPFS_MSG_PUTATTR;
! 461: if (cred != NOCRED) {
! 462: msg.cred.uid = cred->cr_uid;
! 463: msg.cred.pag = xfs_get_pag(cred);
! 464: } else {
! 465: msg.cred.uid = 0;
! 466: msg.cred.pag = NNPFS_ANONYMOUSID;
! 467: }
! 468: msg.handle = xn->handle;
! 469: vattr2xfs_attr(vap, &msg.attr);
! 470: if (NNPFS_TOKEN_GOT(xn, NNPFS_DATA_R)) {
! 471: if (vp->v_type == VREG) {
! 472: if (vap->va_size != (va_size_t)VNOVAL)
! 473: XA_SET_SIZE(&msg.attr, vap->va_size);
! 474: else
! 475: XA_SET_SIZE(&msg.attr, xn->attr.va_size);
! 476: #ifdef __APPLE__
! 477: /* XXX needed ? */
! 478: if (UBCINFOEXISTS(vp))
! 479: ubc_setsize(vp, msg.attr.xa_size);
! 480: #endif
! 481: }
! 482: if (vap->va_mtime.tv_sec != (unsigned int)VNOVAL)
! 483: XA_SET_MTIME(&msg.attr, vap->va_mtime.tv_sec);
! 484: else
! 485: XA_SET_MTIME(&msg.attr, xn->attr.va_mtime.tv_sec);
! 486: }
! 487:
! 488: NNPFS_TOKEN_CLEAR(xn, NNPFS_ATTR_VALID, NNPFS_ATTR_MASK);
! 489: error = xfs_message_rpc(xfsp->fd, &msg.header, sizeof(msg), p);
! 490: if (error == 0)
! 491: error = ((struct xfs_message_wakeup *) & msg)->error;
! 492: }
! 493:
! 494: done:
! 495: return error;
! 496: }
! 497:
! 498: static int
! 499: check_rights (u_char rights, int mode)
! 500: {
! 501: int error = 0;
! 502:
! 503: if (mode & VREAD)
! 504: if ((rights & NNPFS_RIGHT_R) == 0)
! 505: error = EACCES;
! 506: if (mode & VWRITE)
! 507: if ((rights & NNPFS_RIGHT_W) == 0)
! 508: error = EACCES;
! 509: if (mode & VEXEC)
! 510: if ((rights & NNPFS_RIGHT_X) == 0)
! 511: error = EACCES;
! 512: return error;
! 513: }
! 514:
! 515: int
! 516: xfs_access_common(struct vnode *vp, int mode, struct ucred *cred,
! 517: d_thread_t *p)
! 518: {
! 519: int error = 0;
! 520: xfs_pag_t pag = xfs_get_pag(cred);
! 521:
! 522: NNPFSDEB(XDEBVNOPS, ("xfs_access mode = 0%o\n", mode));
! 523:
! 524: error = xfs_attr_valid(vp, cred, p, NNPFS_ATTR_R);
! 525: if (error == 0) {
! 526: struct xfs_node *xn = VNODE_TO_XNODE(vp);
! 527: int i;
! 528:
! 529: error = check_rights (xn->anonrights, mode);
! 530:
! 531: if (error == 0)
! 532: goto done;
! 533:
! 534: NNPFSDEB(XDEBVNOPS, ("xfs_access anonaccess failed\n"));
! 535:
! 536: error = EACCES; /* default to EACCES if pag isn't in xn->id */
! 537:
! 538: for (i = 0; i < MAXRIGHTS; i++)
! 539: if (xn->id[i] == pag) {
! 540: error = check_rights (xn->rights[i], mode);
! 541: break;
! 542: }
! 543: }
! 544:
! 545: done:
! 546: NNPFSDEB(XDEBVNOPS, ("xfs_access(0%o) = %d\n", mode, error));
! 547:
! 548: return error;
! 549: }
! 550:
! 551: int
! 552: xfs_lookup_common(struct vnode *dvp,
! 553: xfs_componentname *cnp,
! 554: struct vnode **vpp)
! 555: {
! 556: struct xfs_message_getnode msg;
! 557: struct xfs *xfsp = NNPFS_FROM_VNODE(dvp);
! 558: struct xfs_node *d = VNODE_TO_XNODE(dvp);
! 559: int error = 0;
! 560: #ifdef HAVE_FREEBSD_THREAD
! 561: d_thread_t *proc = xfs_cnp_to_thread(cnp);
! 562: struct ucred *cred = xfs_thread_to_cred(proc);
! 563: #else
! 564: d_thread_t *proc = xfs_cnp_to_proc(cnp);
! 565: struct ucred *cred = xfs_proc_to_cred(proc);
! 566: #endif
! 567:
! 568: NNPFSDEB(XDEBVNOPS, ("xfs_lookup_common: enter\n"));
! 569:
! 570: *vpp = NULL;
! 571:
! 572: if (cnp->cn_namelen >= NNPFS_MAX_NAME)
! 573: return ENAMETOOLONG;
! 574:
! 575: if (dvp->v_type != VDIR)
! 576: return ENOTDIR;
! 577:
! 578: if (cnp->cn_namelen == 1 && cnp->cn_nameptr[0] == '.') {
! 579: *vpp = dvp;
! 580: VREF(*vpp);
! 581: return 0;
! 582: }
! 583:
! 584: do {
! 585: xfs_vop_access(dvp, VEXEC, cred, proc, error);
! 586: if (error != 0)
! 587: goto done;
! 588:
! 589: NNPFSDEB(XDEBVNOPS, ("xfs_lookup_common: dvp = %lx\n",
! 590: (unsigned long) dvp));
! 591: NNPFSDEB(XDEBVNOPS, ("xfs_lookup_common: cnp = %lx, "
! 592: "cnp->cn_nameiop = %d\n",
! 593: (unsigned long) cnp, (int)cnp->cn_nameiop));
! 594:
! 595:
! 596: error = xfs_dnlc_lookup(dvp, cnp, vpp);
! 597: if (error == 0) {
! 598:
! 599: /*
! 600: * Doesn't quite work.
! 601: */
! 602:
! 603: #if 0
! 604: if ((cnp->cn_nameiop == CREATE || cnp->cn_nameiop == RENAME)
! 605: && (cnp->cn_flags & ISLASTCN)) {
! 606: error = EJUSTRETURN;
! 607: goto done;
! 608: }
! 609: #endif
! 610:
! 611: msg.header.opcode = NNPFS_MSG_GETNODE;
! 612: if (cnp->cn_cred != NOCRED) {
! 613: msg.cred.uid = cnp->cn_cred->cr_uid;
! 614: msg.cred.pag = xfs_get_pag(cnp->cn_cred);
! 615: } else {
! 616: msg.cred.uid = 0;
! 617: msg.cred.pag = NNPFS_ANONYMOUSID;
! 618: }
! 619: msg.parent_handle = d->handle;
! 620: memcpy(msg.name, cnp->cn_nameptr, cnp->cn_namelen);
! 621: msg.name[cnp->cn_namelen] = '\0';
! 622: error = xfs_message_rpc(xfsp->fd, &msg.header,
! 623: sizeof(msg), proc);
! 624: if (error == 0)
! 625: error = ((struct xfs_message_wakeup *) & msg)->error;
! 626: if(error == ENOENT && cnp->cn_nameiop != CREATE) {
! 627: NNPFSDEB(XDEBVNOPS, ("xfs_lookup: neg cache %lx (%s, %ld)\n",
! 628: (unsigned long)dvp,
! 629: cnp->cn_nameptr, cnp->cn_namelen));
! 630: xfs_dnlc_enter (dvp, cnp, NULL);
! 631: }
! 632: } else if (error == -1) {
! 633: error = 0;
! 634: goto done;
! 635: }
! 636: } while (error == 0);
! 637:
! 638: done:
! 639: NNPFSDEB(XDEBVNOPS, ("xfs_lookup_common: return error = %d\n", error));
! 640: return error;
! 641: }
! 642:
! 643: int
! 644: xfs_create_common(struct vnode *dvp,
! 645: const char *name,
! 646: struct vattr *vap,
! 647: struct ucred *cred,
! 648: d_thread_t *p)
! 649: {
! 650: struct xfs *xfsp = NNPFS_FROM_VNODE(dvp);
! 651: struct xfs_node *xn = VNODE_TO_XNODE(dvp);
! 652: int error = 0;
! 653:
! 654: NNPFSDEB(XDEBVNOPS, ("xfs_create: (%lx, %s)\n",
! 655: (unsigned long)dvp, name));
! 656: {
! 657: struct xfs_message_create msg;
! 658:
! 659: msg.header.opcode = NNPFS_MSG_CREATE;
! 660: msg.parent_handle = xn->handle;
! 661: if (strlcpy(msg.name, name, sizeof(msg.name)) >= NNPFS_MAX_NAME)
! 662: return ENAMETOOLONG;
! 663: vattr2xfs_attr(vap, &msg.attr);
! 664:
! 665: msg.mode = 0; /* XXX - mode */
! 666: if (cred != NOCRED) {
! 667: msg.cred.uid = cred->cr_uid;
! 668: msg.cred.pag = xfs_get_pag(cred);
! 669: } else {
! 670: msg.cred.uid = 0;
! 671: msg.cred.pag = NNPFS_ANONYMOUSID;
! 672: }
! 673:
! 674:
! 675: error = xfs_message_rpc(xfsp->fd, &msg.header, sizeof(msg), p);
! 676:
! 677: if (error == 0)
! 678: error = ((struct xfs_message_wakeup *) & msg)->error;
! 679: }
! 680:
! 681: #if 0
! 682: if (error == EEXIST)
! 683: error = 0;
! 684: #endif
! 685:
! 686: return error;
! 687: }
! 688:
! 689: int
! 690: xfs_remove_common(struct vnode *dvp,
! 691: struct vnode *vp,
! 692: const char *name,
! 693: struct ucred *cred,
! 694: d_thread_t *p)
! 695: {
! 696: struct xfs *xfsp = NNPFS_FROM_VNODE(dvp);
! 697: struct xfs_node *xn = VNODE_TO_XNODE(dvp);
! 698: struct xfs_message_remove msg;
! 699: int error;
! 700:
! 701: NNPFSDEB(XDEBVNOPS, ("xfs_remove: %s\n", name));
! 702:
! 703: msg.header.opcode = NNPFS_MSG_REMOVE;
! 704: msg.parent_handle = xn->handle;
! 705: msg.cred.uid = cred->cr_uid;
! 706: msg.cred.pag = xfs_get_pag(cred);
! 707:
! 708: if (strlcpy(msg.name, name, sizeof(msg.name)) >= NNPFS_MAX_NAME)
! 709: error = ENAMETOOLONG;
! 710: else
! 711: error = xfs_message_rpc(xfsp->fd, &msg.header, sizeof(msg), p);
! 712: if (error == 0)
! 713: error = ((struct xfs_message_wakeup *) &msg)->error;
! 714:
! 715: if (error == 0)
! 716: xfs_dnlc_purge (vp);
! 717:
! 718: return error;
! 719: }
! 720:
! 721: int
! 722: xfs_rename_common(struct vnode *fdvp,
! 723: struct vnode *fvp,
! 724: const char *fname,
! 725: struct vnode *tdvp,
! 726: struct vnode *tvp,
! 727: const char *tname,
! 728: struct ucred *cred,
! 729: d_thread_t *p)
! 730: {
! 731: struct xfs *xfsp = NNPFS_FROM_VNODE(fdvp);
! 732: int error;
! 733:
! 734: NNPFSDEB(XDEBVNOPS, ("xfs_rename: %s %s\n", fname, tname));
! 735:
! 736: if ((fvp->v_mount != tdvp->v_mount)
! 737: || (tvp && (fvp->v_mount != tvp->v_mount))) {
! 738: return EXDEV;
! 739: }
! 740:
! 741: {
! 742: struct xfs_message_rename msg;
! 743:
! 744: msg.header.opcode = NNPFS_MSG_RENAME;
! 745: msg.old_parent_handle = VNODE_TO_XNODE(fdvp)->handle;
! 746: if (strlcpy(msg.old_name, fname, sizeof(msg.old_name)) >= NNPFS_MAX_NAME)
! 747: return ENAMETOOLONG;
! 748: msg.new_parent_handle = VNODE_TO_XNODE(tdvp)->handle;
! 749: if (strlcpy(msg.new_name, tname, sizeof(msg.new_name)) >= NNPFS_MAX_NAME)
! 750: return ENAMETOOLONG;
! 751: msg.cred.uid = cred->cr_uid;
! 752: msg.cred.pag = xfs_get_pag(cred);
! 753: error = xfs_message_rpc(xfsp->fd, &msg.header, sizeof(msg), p);
! 754: if (error == 0)
! 755: error = ((struct xfs_message_wakeup *) &msg)->error;
! 756:
! 757: }
! 758:
! 759: NNPFSDEB(XDEBVNOPS, ("xfs_rename: error = %d\n", error));
! 760:
! 761: return error;
! 762: }
! 763:
! 764: int
! 765: xfs_mkdir_common(struct vnode *dvp,
! 766: const char *name,
! 767: struct vattr *vap,
! 768: struct ucred *cred,
! 769: d_thread_t *p)
! 770: {
! 771: struct xfs *xfsp = NNPFS_FROM_VNODE(dvp);
! 772: struct xfs_node *xn = VNODE_TO_XNODE(dvp);
! 773: int error = 0;
! 774:
! 775: NNPFSDEB(XDEBVNOPS, ("xfs_mkdir: %s\n", name));
! 776: {
! 777: struct xfs_message_mkdir msg;
! 778:
! 779: msg.header.opcode = NNPFS_MSG_MKDIR;
! 780: msg.parent_handle = xn->handle;
! 781: if (strlcpy(msg.name, name, sizeof(msg.name)) >= NNPFS_MAX_NAME)
! 782: return ENAMETOOLONG;
! 783: vattr2xfs_attr(vap, &msg.attr);
! 784: if (cred != NOCRED) {
! 785: msg.cred.uid = cred->cr_uid;
! 786: msg.cred.pag = xfs_get_pag(cred);
! 787: } else {
! 788: msg.cred.uid = 0;
! 789: msg.cred.pag = NNPFS_ANONYMOUSID;
! 790: }
! 791: error = xfs_message_rpc(xfsp->fd, &msg.header, sizeof(msg), p);
! 792: if (error == 0)
! 793: error = ((struct xfs_message_wakeup *) & msg)->error;
! 794: }
! 795:
! 796: return error;
! 797: }
! 798:
! 799: int
! 800: xfs_rmdir_common(struct vnode *dvp,
! 801: struct vnode *vp,
! 802: const char *name,
! 803: struct ucred *cred,
! 804: d_thread_t *p)
! 805: {
! 806: struct xfs *xfsp = NNPFS_FROM_VNODE(dvp);
! 807: struct xfs_node *xn = VNODE_TO_XNODE(dvp);
! 808: struct xfs_message_rmdir msg;
! 809: int error;
! 810:
! 811: NNPFSDEB(XDEBVNOPS, ("xfs_rmdir: %s\n", name));
! 812:
! 813: msg.header.opcode = NNPFS_MSG_RMDIR;
! 814: msg.parent_handle = xn->handle;
! 815: msg.cred.uid = cred->cr_uid;
! 816: msg.cred.pag = xfs_get_pag(cred);
! 817: if (strlcpy(msg.name, name, sizeof(msg.name)) >= NNPFS_MAX_NAME)
! 818: error = ENAMETOOLONG;
! 819: else
! 820: error = xfs_message_rpc(xfsp->fd, &msg.header, sizeof(msg), p);
! 821: if (error == 0)
! 822: error = ((struct xfs_message_wakeup *) &msg)->error;
! 823:
! 824: if (error == 0)
! 825: xfs_dnlc_purge (vp);
! 826:
! 827: NNPFSDEB(XDEBVNOPS, ("xfs_rmdir error: %d\n", error));
! 828:
! 829: return error;
! 830: }
! 831:
! 832: int
! 833: xfs_readdir_common(struct vnode *vp,
! 834: struct uio *uiop,
! 835: struct ucred *cred,
! 836: d_thread_t *p,
! 837: int *eofflag)
! 838: {
! 839: int error = 0;
! 840:
! 841: NNPFSDEB(XDEBVNOPS, ("xfs_readdir\n"));
! 842:
! 843: if(eofflag)
! 844: *eofflag = 0;
! 845: #ifdef HAVE_FREEBSD_THREAD
! 846: error = xfs_data_valid(vp, cred, xfs_uio_to_thread(uiop), NNPFS_DATA_R,
! 847: xfs_uio_end_length(uiop));
! 848: #else
! 849: error = xfs_data_valid(vp, cred, xfs_uio_to_proc(uiop), NNPFS_DATA_R,
! 850: xfs_uio_end_length(uiop));
! 851: #endif
! 852: if (error == 0) {
! 853: struct vnode *t = DATA_FROM_VNODE(vp);
! 854:
! 855: #ifdef HAVE_FREEBSD_THREAD
! 856: xfs_vfs_readlock(t, xfs_uio_to_thread(uiop));
! 857: #else
! 858: xfs_vfs_readlock(t, xfs_uio_to_proc(uiop));
! 859: #endif
! 860: xfs_vop_read(t, uiop, 0, cred, error);
! 861: if (eofflag) {
! 862: struct vattr t_attr;
! 863: int error2;
! 864:
! 865: #ifdef HAVE_FREEBSD_THREAD
! 866: xfs_vop_getattr(t, &t_attr, cred, xfs_uio_to_thread(uiop), error2);
! 867: #else
! 868: xfs_vop_getattr(t, &t_attr, cred, xfs_uio_to_proc(uiop), error2);
! 869: #endif
! 870: if (error2 == 0)
! 871: *eofflag = t_attr.va_size <= uiop->uio_offset;
! 872: }
! 873: #ifdef HAVE_FREEBSD_THREAD
! 874: xfs_vfs_unlock(t, xfs_uio_to_thread(uiop));
! 875: #else
! 876: xfs_vfs_unlock(t, xfs_uio_to_proc(uiop));
! 877: #endif
! 878: }
! 879: return error;
! 880: }
! 881:
! 882: int
! 883: xfs_link_common(struct vnode *dvp,
! 884: struct vnode *vp,
! 885: const char *name,
! 886: struct ucred *cred,
! 887: d_thread_t *p)
! 888: {
! 889: struct xfs *xfsp = NNPFS_FROM_VNODE(dvp);
! 890: struct xfs_node *xn = VNODE_TO_XNODE(dvp);
! 891: struct xfs_node *xn2 = VNODE_TO_XNODE(vp);
! 892: struct xfs_message_link msg;
! 893: int error = 0;
! 894:
! 895: NNPFSDEB(XDEBVNOPS, ("xfs_link: %s\n", name));
! 896:
! 897: msg.header.opcode = NNPFS_MSG_LINK;
! 898: msg.parent_handle = xn->handle;
! 899: msg.from_handle = xn2->handle;
! 900: if (strlcpy(msg.name, name, sizeof(msg.name)) >= NNPFS_MAX_NAME)
! 901: return ENAMETOOLONG;
! 902: msg.cred.uid = cred->cr_uid;
! 903: msg.cred.pag = xfs_get_pag(cred);
! 904:
! 905: error = xfs_message_rpc(xfsp->fd, &msg.header, sizeof(msg), p);
! 906: if (error == 0)
! 907: error = ((struct xfs_message_wakeup *) & msg)->error;
! 908:
! 909: return error;
! 910: }
! 911:
! 912: int
! 913: xfs_symlink_common(struct vnode *dvp,
! 914: struct vnode **vpp,
! 915: xfs_componentname *cnp,
! 916: struct vattr *vap,
! 917: char *target)
! 918: {
! 919: struct xfs *xfsp = NNPFS_FROM_VNODE(dvp);
! 920: struct xfs_node *xn = VNODE_TO_XNODE(dvp);
! 921: #ifdef HAVE_FREEBSD_THREAD
! 922: d_thread_t *proc = xfs_cnp_to_thread(cnp);
! 923: struct ucred *cred = xfs_thread_to_cred(proc);
! 924: #else
! 925: d_thread_t *proc = xfs_cnp_to_proc(cnp);
! 926: struct ucred *cred = xfs_proc_to_cred(proc);
! 927: #endif
! 928: struct xfs_message_symlink *msg = NULL;
! 929: const char *name = cnp->cn_nameptr;
! 930: int error = 0;
! 931:
! 932: NNPFSDEB(XDEBVNOPS, ("xfs_symlink: %s\n", name));
! 933:
! 934: msg = malloc(sizeof(struct xfs_message_symlink), M_TEMP, M_WAITOK);
! 935: if (msg == NULL) {
! 936: error = ENOMEM;
! 937: goto done;
! 938: }
! 939: memset(msg, 0, sizeof(*msg));
! 940:
! 941: msg->header.opcode = NNPFS_MSG_SYMLINK;
! 942: msg->parent_handle = xn->handle;
! 943: vattr2xfs_attr(vap, &msg->attr);
! 944: msg->cred.uid = cred->cr_uid;
! 945: msg->cred.pag = xfs_get_pag(cred);
! 946: if (strlcpy (msg->contents, target, sizeof(msg->contents)) >= NNPFS_MAX_SYMLINK_CONTENT) {
! 947: error = ENAMETOOLONG;
! 948: goto done;
! 949: }
! 950: if (strlcpy(msg->name, name, sizeof(msg->name)) >= NNPFS_MAX_NAME) {
! 951: error = ENAMETOOLONG;
! 952: goto done;
! 953: }
! 954: error = xfs_message_rpc(xfsp->fd, &msg->header, sizeof(*msg), proc);
! 955: if (error == 0)
! 956: error = ((struct xfs_message_wakeup *) msg)->error;
! 957:
! 958: done:
! 959: free(msg, M_TEMP);
! 960: return error;
! 961: }
! 962:
! 963: int
! 964: xfs_readlink_common(struct vnode *vp, struct uio *uiop, struct ucred *cred)
! 965: {
! 966: int error = 0;
! 967:
! 968: NNPFSDEB(XDEBVNOPS, ("xfs_readlink\n"));
! 969:
! 970: #ifdef HAVE_FREEBSD_THREAD
! 971: error = xfs_data_valid(vp, cred, xfs_uio_to_thread(uiop), NNPFS_DATA_R,
! 972: xfs_uio_end_length(uiop));
! 973: #else
! 974: error = xfs_data_valid(vp, cred, xfs_uio_to_proc(uiop), NNPFS_DATA_R,
! 975: xfs_uio_end_length(uiop));
! 976: #endif
! 977: if (error == 0) {
! 978: struct vnode *t = DATA_FROM_VNODE(vp);
! 979:
! 980: #ifdef HAVE_FREEBSD_THREAD
! 981: xfs_vfs_readlock(t, xfs_uio_to_thread(uiop));
! 982: xfs_vop_read(t, uiop, 0, cred, error);
! 983: xfs_vfs_unlock(t, xfs_uio_to_thread(uiop));
! 984: #else
! 985: xfs_vfs_readlock(t, xfs_uio_to_proc(uiop));
! 986: xfs_vop_read(t, uiop, 0, cred, error);
! 987: xfs_vfs_unlock(t, xfs_uio_to_proc(uiop));
! 988: #endif
! 989: }
! 990: return error;
! 991: }
! 992:
! 993: int
! 994: xfs_inactive_common(struct vnode *vp, d_thread_t *p)
! 995: {
! 996: int error;
! 997: struct xfs_node *xn = VNODE_TO_XNODE(vp);
! 998:
! 999: NNPFSDEB(XDEBVNOPS, ("xfs_inactive, %lx\n",
! 1000: (unsigned long)vp));
! 1001:
! 1002: /*
! 1003: * This seems rather bogus, but sometimes we get an already
! 1004: * cleaned node to be made inactive. Just ignoring it seems safe.
! 1005: */
! 1006:
! 1007: if (xn == NULL) {
! 1008: NNPFSDEB(XDEBVNOPS, ("xfs_inactive: clean node\n"));
! 1009: return 0;
! 1010: }
! 1011:
! 1012: /* xn->wr_cred not set -> NOCRED */
! 1013:
! 1014: if (vp->v_type == VREG)
! 1015: xfs_pushdirty(vp, xn->wr_cred, p);
! 1016:
! 1017: error = xfs_fsync_common(vp, xn->wr_cred, /* XXX */ 0, p);
! 1018: if (error) {
! 1019: printf ("xfs_inactive: failed writing back data: %d\n", error);
! 1020: xn->flags &= ~NNPFS_DATA_DIRTY;
! 1021: }
! 1022:
! 1023: /* If this node is no longer valid, recycle immediately. */
! 1024: if (!NNPFS_TOKEN_GOT(xn, NNPFS_ATTR_R | NNPFS_ATTR_W)
! 1025: || (xn->flags & NNPFS_STALE) == NNPFS_STALE)
! 1026: {
! 1027: #ifndef __osf__
! 1028: xfs_vfs_unlock(vp, p);
! 1029: NNPFSDEB(XDEBVNOPS, ("xfs_inactive: vrecycle\n"));
! 1030: vrecycle(vp, p);
! 1031: #else /* __osf__ */
! 1032: NNPFSDEB(XDEBVNOPS, ("xfs_inactive: vp = %lx vp->v_usecount= %d\n",
! 1033: (unsigned long)vp, vp?vp->v_usecount:0));
! 1034: #endif /* __osf__ */
! 1035: } else {
! 1036: #ifndef __osf__
! 1037: xfs_vfs_unlock(vp, p);
! 1038: #endif
! 1039: xn->flags &= ~NNPFS_STALE;
! 1040: }
! 1041:
! 1042: NNPFSDEB(XDEBVNOPS, ("return: xfs_inactive\n"));
! 1043:
! 1044: return 0;
! 1045: }
! 1046:
! 1047: int
! 1048: xfs_reclaim_common(struct vnode *vp)
! 1049: {
! 1050: struct xfs_message_inactivenode msg;
! 1051: struct xfs *xfsp = NNPFS_FROM_VNODE(vp);
! 1052: struct xfs_node *xn = VNODE_TO_XNODE(vp);
! 1053:
! 1054: NNPFSDEB(XDEBVNOPS, ("xfs_reclaim: %lx\n",
! 1055: (unsigned long)vp));
! 1056:
! 1057: NNPFS_TOKEN_CLEAR(xn,
! 1058: ~0,
! 1059: NNPFS_OPEN_MASK | NNPFS_ATTR_MASK |
! 1060: NNPFS_DATA_MASK | NNPFS_LOCK_MASK);
! 1061: /* Release, data if we still have it. */
! 1062: if (DATA_FROM_XNODE(xn) != 0) {
! 1063: vrele(DATA_FROM_XNODE(xn));
! 1064: DATA_FROM_XNODE(xn) = 0;
! 1065: }
! 1066:
! 1067: xfs_remove_node(&xfsp->nodehead, xn);
! 1068:
! 1069: msg.header.opcode = NNPFS_MSG_INACTIVENODE;
! 1070: msg.handle = xn->handle;
! 1071: msg.flag = NNPFS_NOREFS | NNPFS_DELETE;
! 1072: xfs_message_send(xfsp->fd, &msg.header, sizeof(msg));
! 1073:
! 1074: xfs_dnlc_purge(vp);
! 1075: free_xfs_node(xn);
! 1076: return 0;
! 1077: }
! 1078:
! 1079: /*
! 1080: *
! 1081: */
! 1082:
! 1083: #if 0
! 1084:
! 1085: int
! 1086: xfs_advlock_common(struct vnode *dvp,
! 1087: int locktype,
! 1088: unsigned long lockid, /* XXX this good ? */
! 1089: struct ucred *cred)
! 1090: {
! 1091: struct xfs *xfsp = NNPFS_FROM_VNODE(dvp);
! 1092: struct xfs_node *xn = VNODE_TO_XNODE(dvp);
! 1093: int error = 0;
! 1094:
! 1095: NNPFSDEB(XDEBVNOPS, ("xfs_advlock\n"));
! 1096: {
! 1097: struct xfs_message_advlock msg;
! 1098:
! 1099: msg.header.opcode = NNPFS_MSG_ADVLOCK;
! 1100: msg.handle = xn->handle;
! 1101: msg.locktype = locktype;
! 1102: msg.lockid = lockid;
! 1103:
! 1104: if (cred != NOCRED) {
! 1105: msg.cred.uid = cred->cr_uid;
! 1106: msg.cred.pag = xfs_get_pag(cred);
! 1107: } else {
! 1108: msg.cred.uid = 0;
! 1109: msg.cred.pag = NNPFS_ANONYMOUSID;
! 1110: }
! 1111: error = xfs_message_rpc(xfsp->fd, &msg.header, sizeof(msg), p);
! 1112: if (error == 0)
! 1113: error = ((struct xfs_message_wakeup *) & msg)->error;
! 1114: }
! 1115:
! 1116: if (error == 0) {
! 1117:
! 1118: /* sleep until woken */
! 1119:
! 1120: } else {
! 1121:
! 1122: /* die */
! 1123: }
! 1124:
! 1125: return error;
! 1126: }
! 1127:
! 1128: #endif
! 1129:
! 1130: /*
! 1131: *
! 1132: */
! 1133:
! 1134: void
! 1135: xfs_printnode_common (struct vnode *vp)
! 1136: {
! 1137: struct xfs_node *xn = VNODE_TO_XNODE(vp);
! 1138:
! 1139: printf ("xnode: fid: %d.%d.%d.%d\n",
! 1140: xn->handle.a, xn->handle.b, xn->handle.c, xn->handle.d);
! 1141: printf ("\tattr: %svalid\n",
! 1142: NNPFS_TOKEN_GOT(xn, NNPFS_ATTR_VALID) ? "": "in");
! 1143: printf ("\tdata: %svalid\n",
! 1144: NNPFS_TOKEN_GOT(xn, NNPFS_DATA_VALID) ? "": "in");
! 1145: printf ("\tflags: 0x%x\n", xn->flags);
! 1146: printf ("\toffset: %d\n", xn->offset);
! 1147: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to xfs_vnodeops-common.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / xfs