Annotation of sys/xfs/xfs_message.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: #include <xfs/xfs_locl.h>
! 35: #include <xfs/xfs_deb.h>
! 36: #include <xfs/xfs_fs.h>
! 37: #include <xfs/xfs_message.h>
! 38: #include <xfs/xfs_msg_locl.h>
! 39: #include <xfs/xfs_syscalls.h>
! 40: #include <xfs/xfs_vfsops.h>
! 41: #include <xfs/xfs_vnodeops.h>
! 42: #include <xfs/xfs_dev.h>
! 43:
! 44: RCSID("$arla: xfs_message.c,v 1.84 2003/06/02 18:25:20 lha Exp $");
! 45:
! 46: static void
! 47: send_inactive_node(int fd, xfs_handle *handle)
! 48: {
! 49: struct xfs_message_inactivenode msg;
! 50:
! 51: msg.header.opcode = NNPFS_MSG_INACTIVENODE;
! 52: msg.handle = *handle;
! 53: msg.flag = NNPFS_NOREFS | NNPFS_DELETE;
! 54: xfs_message_send(fd, &msg.header, sizeof(msg));
! 55: }
! 56:
! 57:
! 58: int
! 59: xfs_message_installroot(int fd,
! 60: struct xfs_message_installroot * message,
! 61: u_int size,
! 62: d_thread_t *p)
! 63: {
! 64: int error = 0;
! 65:
! 66: NNPFSDEB(XDEBMSG, ("xfs_message_installroot (%d,%d,%d,%d)\n",
! 67: message->node.handle.a,
! 68: message->node.handle.b,
! 69: message->node.handle.c,
! 70: message->node.handle.d));
! 71:
! 72: if (xfs[fd].root != NULL) {
! 73: printf("NNPFS PANIC WARNING! xfs_message_installroot: called again!\n");
! 74: error = EBUSY;
! 75: } else {
! 76: error = new_xfs_node(&xfs[fd], &message->node, &xfs[fd].root, p);
! 77: if (error)
! 78: return error;
! 79: NNPFS_MAKE_VROOT(xfs[fd].root->vn);
! 80: }
! 81: return error;
! 82: }
! 83:
! 84: int
! 85: xfs_message_installnode(int fd,
! 86: struct xfs_message_installnode * message,
! 87: u_int size,
! 88: d_thread_t *p)
! 89: {
! 90: int error = 0;
! 91: struct xfs_node *n, *dp;
! 92:
! 93: NNPFSDEB(XDEBMSG, ("xfs_message_installnode (%d,%d,%d,%d)\n",
! 94: message->node.handle.a,
! 95: message->node.handle.b,
! 96: message->node.handle.c,
! 97: message->node.handle.d));
! 98:
! 99: retry:
! 100: dp = xfs_node_find(&xfs[fd].nodehead, &message->parent_handle);
! 101: if (dp) {
! 102: struct vnode *t_vnode = XNODE_TO_VNODE(dp);
! 103:
! 104: NNPFSDEB(XDEBMSG, ("xfs_message_installnode: t_vnode = %lx\n",
! 105: (unsigned long)t_vnode));
! 106:
! 107: if (xfs_do_vget(t_vnode, 0 /* LK_SHARED */, p))
! 108: goto retry;
! 109:
! 110: error = new_xfs_node(&xfs[fd], &message->node, &n, p);
! 111: if (error) {
! 112: vrele (t_vnode);
! 113: return error;
! 114: }
! 115:
! 116: xfs_dnlc_enter_name(t_vnode,
! 117: message->name,
! 118: XNODE_TO_VNODE(n));
! 119: vrele (XNODE_TO_VNODE(n));
! 120: vrele (t_vnode);
! 121: } else {
! 122: printf("NNPFS PANIC WARNING! xfs_message_installnode: no parent\n");
! 123: error = ENOENT;
! 124: }
! 125: NNPFSDEB(XDEBMSG, ("return: xfs_message_installnode: %d\n", error));
! 126:
! 127: return error;
! 128: }
! 129:
! 130: int
! 131: xfs_message_installattr(int fd,
! 132: struct xfs_message_installattr * message,
! 133: u_int size,
! 134: d_thread_t *p)
! 135: {
! 136: int error = 0;
! 137: struct xfs_node *t;
! 138:
! 139: NNPFSDEB(XDEBMSG, ("xfs_message_installattr (%d,%d,%d,%d) \n",
! 140: message->node.handle.a,
! 141: message->node.handle.b,
! 142: message->node.handle.c,
! 143: message->node.handle.d));
! 144:
! 145: t = xfs_node_find(&xfs[fd].nodehead, &message->node.handle);
! 146: if (t != 0) {
! 147: t->tokens = message->node.tokens;
! 148: if ((t->tokens & NNPFS_DATA_MASK) && DATA_FROM_XNODE(t) == NULL) {
! 149: printf ("xfs_message_installattr: tokens and no data\n");
! 150: t->tokens &= ~NNPFS_DATA_MASK;
! 151: }
! 152: xfs_attr2vattr(&message->node.attr, &t->attr, 0);
! 153: if ((t->flags & NNPFS_VMOPEN) == 0)
! 154: xfs_set_vp_size(XNODE_TO_VNODE(t), t->attr.va_size);
! 155: bcopy(message->node.id, t->id, sizeof(t->id));
! 156: bcopy(message->node.rights, t->rights, sizeof(t->rights));
! 157: t->anonrights = message->node.anonrights;
! 158: } else {
! 159: NNPFSDEB(XDEBMSG, ("xfs_message_installattr: no such node\n"));
! 160: }
! 161:
! 162: return error;
! 163: }
! 164:
! 165: int
! 166: xfs_message_installdata(int fd,
! 167: struct xfs_message_installdata * message,
! 168: u_int size,
! 169: d_thread_t *p)
! 170: {
! 171: struct xfs_node *t;
! 172: int error = 0;
! 173:
! 174: NNPFSDEB(XDEBMSG, ("xfs_message_installdata (%d,%d,%d,%d)\n",
! 175: message->node.handle.a,
! 176: message->node.handle.b,
! 177: message->node.handle.c,
! 178: message->node.handle.d));
! 179:
! 180: retry:
! 181: t = xfs_node_find(&xfs[fd].nodehead, &message->node.handle);
! 182: if (t != NULL) {
! 183: struct xfs_fhandle_t *fh =
! 184: (struct xfs_fhandle_t *)&message->cache_handle;
! 185: struct vnode *t_vnode = XNODE_TO_VNODE(t);
! 186: struct vnode *vp;
! 187:
! 188: message->cache_name[sizeof(message->cache_name)-1] = '\0';
! 189: NNPFSDEB(XDEBMSG, ("cache_name = '%s'\n", message->cache_name));
! 190:
! 191: if (xfs_do_vget(t_vnode, 0 /* LK_SHARED */, p))
! 192: goto retry;
! 193:
! 194: if (message->flag & NNPFS_ID_HANDLE_VALID) {
! 195: error = xfs_fhlookup (p, fh, &vp);
! 196: } else {
! 197: error = EINVAL;
! 198: }
! 199: if (error != 0) {
! 200: #ifdef __osf__
! 201: struct nameidata *ndp = &u.u_nd;
! 202: #else
! 203: struct nameidata nd;
! 204: struct nameidata *ndp = &nd;
! 205: #endif
! 206:
! 207: NNPFSDEB(XDEBMSG,
! 208: ("xfs_message_installdata: fhlookup failed: %d, "
! 209: "opening by name\n", error));
! 210:
! 211: NDINIT(ndp, LOOKUP, FOLLOW | NNPFS_LOCKLEAF, UIO_SYSSPACE,
! 212: message->cache_name, p);
! 213: error = namei(ndp);
! 214: vp = ndp->ni_vp;
! 215: }
! 216:
! 217: if (error == 0) {
! 218: #ifndef __osf__
! 219: xfs_vfs_unlock(vp, p);
! 220: #endif
! 221: if (DATA_FROM_XNODE(t))
! 222: vrele(DATA_FROM_XNODE(t));
! 223: DATA_FROM_XNODE(t) = vp;
! 224:
! 225: NNPFSDEB(XDEBMSG, ("xfs_message_installdata: t = %lx;"
! 226: " tokens = %x\n",
! 227: (unsigned long)t, message->node.tokens));
! 228:
! 229: t->tokens = message->node.tokens;
! 230: xfs_attr2vattr(&message->node.attr, &t->attr, 1);
! 231: if ((t->flags & NNPFS_VMOPEN) == 0)
! 232: xfs_set_vp_size(XNODE_TO_VNODE(t), t->attr.va_size);
! 233: if (XNODE_TO_VNODE(t)->v_type == VDIR
! 234: && (message->flag & NNPFS_ID_INVALID_DNLC))
! 235: xfs_dnlc_purge (XNODE_TO_VNODE(t));
! 236: bcopy(message->node.id, t->id, sizeof(t->id));
! 237: bcopy(message->node.rights, t->rights, sizeof(t->rights));
! 238: t->anonrights = message->node.anonrights;
! 239: t->offset = message->offset;
! 240: #if 0
! 241: if (message->flag & NNPFS_ID_AFSDIR)
! 242: t->flags |= NNPFS_AFSDIR;
! 243: #endif
! 244: } else {
! 245: printf("NNPFS PANIC WARNING! xfs_message_installdata failed!\n");
! 246: printf("Reason: lookup failed on cache file '%s', error = %d\n",
! 247: message->cache_name, error);
! 248: }
! 249: vrele (t_vnode);
! 250: } else {
! 251: printf("NNPFS PANIC WARNING! xfs_message_installdata failed\n");
! 252: printf("Reason: No node to install the data into!\n");
! 253: error = ENOENT;
! 254: }
! 255:
! 256: return error;
! 257: }
! 258:
! 259: #ifdef __osf__
! 260: #define xfs_writecount v_wrcnt
! 261: #else
! 262: #define xfs_writecount v_writecount
! 263: #endif
! 264:
! 265: int
! 266: xfs_message_invalidnode(int fd,
! 267: struct xfs_message_invalidnode * message,
! 268: u_int size,
! 269: d_thread_t *p)
! 270: {
! 271: int error = 0;
! 272: struct xfs_node *t;
! 273:
! 274: NNPFSDEB(XDEBMSG, ("xfs_message_invalidnode (%d,%d,%d,%d)\n",
! 275: message->handle.a,
! 276: message->handle.b,
! 277: message->handle.c,
! 278: message->handle.d));
! 279:
! 280: #ifdef __APPLE__
! 281: retry:
! 282: #endif
! 283: t = xfs_node_find(&xfs[fd].nodehead, &message->handle);
! 284: if (t != 0) {
! 285: struct vnode *vp = XNODE_TO_VNODE(t);
! 286:
! 287: /* If open for writing, return immediately. Last close:er wins! */
! 288: if (vp->v_usecount >= 0 && vp->xfs_writecount >= 1)
! 289: return 0;
! 290:
! 291: #ifdef __FreeBSD__
! 292: {
! 293: vm_object_t obj = vp->v_object;
! 294:
! 295: if (obj != NULL
! 296: && (obj->ref_count != 0
! 297: #ifdef OBJ_MIGHTBEDIRTY
! 298: || (obj->flags & OBJ_MIGHTBEDIRTY) != 0
! 299: #endif
! 300: ))
! 301: return 0;
! 302:
! 303: }
! 304: #endif /* __FreeBSD__ */
! 305:
! 306: /* If node is in use, mark as stale */
! 307: if (vp->v_usecount > 0 && vp->v_type != VDIR) {
! 308: #ifdef __APPLE__
! 309: if (vget(vp, 0, p))
! 310: goto retry;
! 311:
! 312: if (UBCISVALID(vp) && !ubc_isinuse(vp, 1)) {
! 313: ubc_setsize(vp, 0);
! 314: vrele(vp);
! 315: } else {
! 316: vrele(vp);
! 317: t->flags |= NNPFS_STALE;
! 318: return 0;
! 319: }
! 320: #else
! 321: t->flags |= NNPFS_STALE;
! 322: return 0;
! 323: #endif
! 324: }
! 325:
! 326: if (DATA_FROM_XNODE(t)) {
! 327: vrele(DATA_FROM_XNODE(t));
! 328: DATA_FROM_XNODE(t) = (struct vnode *) 0;
! 329: }
! 330: NNPFS_TOKEN_CLEAR(t, ~0,
! 331: NNPFS_OPEN_MASK | NNPFS_ATTR_MASK |
! 332: NNPFS_DATA_MASK | NNPFS_LOCK_MASK);
! 333: /* Dir changed, must invalidate DNLC. */
! 334: if (vp->v_type == VDIR)
! 335: xfs_dnlc_purge(vp);
! 336: if (vp->v_usecount == 0) {
! 337: #ifndef __osf__
! 338: NNPFSDEB(XDEBVNOPS, ("xfs_message_invalidnode: vrecycle\n"));
! 339: vrecycle(vp, p);
! 340: #else
! 341: /* XXX */
! 342: #endif /* __osf__ */
! 343: }
! 344: } else {
! 345: NNPFSDEB(XDEBMSG, ("xfs_message_invalidnode: no such node\n"));
! 346: send_inactive_node(fd, &message->handle);
! 347: error = ENOENT;
! 348: }
! 349:
! 350: return error;
! 351: }
! 352:
! 353: int
! 354: xfs_message_updatefid(int fd,
! 355: struct xfs_message_updatefid * message,
! 356: u_int size,
! 357: d_thread_t *p)
! 358: {
! 359: int error = 0;
! 360:
! 361: NNPFSDEB(XDEBMSG, ("xfs_message_updatefid (%d,%d,%d,%d) (%d,%d,%d,%d)\n",
! 362: message->old_handle.a,
! 363: message->old_handle.b,
! 364: message->old_handle.c,
! 365: message->old_handle.d,
! 366: message->new_handle.a,
! 367: message->new_handle.b,
! 368: message->new_handle.c,
! 369: message->new_handle.d));
! 370:
! 371: error = xfs_update_handle(&xfs[fd].nodehead,
! 372: &message->old_handle,
! 373: &message->new_handle);
! 374: if (error)
! 375: printf ("NNPFS PANIC WARNING! xfs_message_updatefid: %d\n", error);
! 376: return error;
! 377: }
! 378:
! 379: #if __osf__
! 380:
! 381: /*
! 382: * Try to clean out nodes for the userland daemon
! 383: */
! 384:
! 385: static void
! 386: gc_vnode (struct vnode *vp,
! 387: d_thread_t *p)
! 388: {
! 389: /* This node is on the freelist */
! 390: if (vp->v_usecount <= 0) {
! 391:
! 392: /* DIAGNOSTIC */
! 393: if (vp->v_usecount < 0) {
! 394: vprint("vrele: bad ref count", vp);
! 395: panic("vrele: ref cnt");
! 396: }
! 397:
! 398: NNPFSDEB(XDEBMSG, ("xfs_message_gc: success\n"));
! 399:
! 400: vgone(vp, VX_NOSLEEP, NULL);
! 401: } else {
! 402: NNPFSDEB(XDEBMSG, ("xfs_message_gc: used\n"));
! 403: }
! 404:
! 405: }
! 406:
! 407:
! 408: #else /* !__osf__ */
! 409:
! 410: /*
! 411: * Try to clean out nodes for the userland daemon
! 412: */
! 413:
! 414: static void
! 415: gc_vnode (struct vnode *vp,
! 416: d_thread_t *p)
! 417: {
! 418: #ifdef HAVE_SYS_MUTEX_H
! 419: mtx_lock(&vp->v_interlock);
! 420: #else
! 421: simple_lock(&vp->v_interlock);
! 422: #endif
! 423:
! 424: /* This node is on the freelist */
! 425: if (vp->v_usecount <= 0) {
! 426: #if __FreeBSD__
! 427: vm_object_t obj;
! 428:
! 429: obj = vp->v_object;
! 430:
! 431: if (obj != NULL
! 432: && (obj->ref_count != 0
! 433: #ifdef OBJ_MIGHTBEDIRTY
! 434: || (obj->flags & OBJ_MIGHTBEDIRTY) != 0
! 435: #endif
! 436: )) {
! 437: #ifdef HAVE_SYS_MUTEX_H
! 438: mtx_unlock(&vp->v_interlock);
! 439: #else
! 440: simple_unlock (&vp->v_interlock);
! 441: #endif
! 442: return;
! 443: }
! 444: #endif /* __FreeBSD__ */
! 445:
! 446: #ifdef DIAGNOSTIC
! 447: if (vp->v_usecount < 0 || vp->v_writecount != 0) {
! 448: vprint("vrele: bad ref count", vp);
! 449: panic("vrele: ref cnt");
! 450: }
! 451: #endif /* DIAGNOSTIC */
! 452:
! 453: NNPFSDEB(XDEBMSG, ("xfs_message_gc: success\n"));
! 454:
! 455: #ifdef HAVE_KERNEL_VGONEL
! 456: vgonel (vp, p);
! 457: #else
! 458: #ifdef HAVE_SYS_MUTEX_H
! 459: mtx_unlock(&vp->v_interlock);
! 460: #else
! 461: simple_unlock(&vp->v_interlock);
! 462: #endif
! 463: vgone (vp);
! 464: #endif
! 465:
! 466: } else {
! 467: #ifdef HAVE_SYS_MUTEX_H
! 468: mtx_unlock(&vp->v_interlock);
! 469: #else
! 470: simple_unlock(&vp->v_interlock);
! 471: #endif
! 472: NNPFSDEB(XDEBMSG, ("xfs_message_gc: used\n"));
! 473: }
! 474:
! 475: }
! 476:
! 477: #endif
! 478:
! 479: int
! 480: xfs_message_gc_nodes(int fd,
! 481: struct xfs_message_gc_nodes *message,
! 482: u_int size,
! 483: d_thread_t *p)
! 484: {
! 485: struct xfs_node *node;
! 486: int i;
! 487:
! 488: NNPFSDEB(XDEBMSG, ("xfs_message_gc\n"));
! 489:
! 490: for (i = 0; i < message->len; i++) {
! 491: node = xfs_node_find (&xfs[fd].nodehead, &message->handle[i]);
! 492: if (node)
! 493: gc_vnode(XNODE_TO_VNODE(node), p);
! 494: else {
! 495: NNPFSDEB(XDEBMSG, ("xfs_message_gc_nodes: no such node\n"));
! 496: send_inactive_node(fd, &message->handle[i]);
! 497: }
! 498: }
! 499:
! 500: return 0;
! 501: }
! 502:
! 503:
! 504: /*
! 505: * Probe what version of xfs this support
! 506: */
! 507:
! 508: int
! 509: xfs_message_version(int fd,
! 510: struct xfs_message_version *message,
! 511: u_int size,
! 512: d_thread_t *p)
! 513: {
! 514: struct xfs_message_wakeup msg;
! 515: int ret;
! 516:
! 517: ret = NNPFS_VERSION;
! 518:
! 519: msg.header.opcode = NNPFS_MSG_WAKEUP;
! 520: msg.sleepers_sequence_num = message->header.sequence_num;
! 521: msg.error = ret;
! 522:
! 523: return xfs_message_send(fd,
! 524: (struct xfs_message_header *) &msg, sizeof(msg));
! 525: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to xfs_message.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / xfs