root/xfs/xfs_message.c

DEFINITIONS

1. send_inactive_node
2. xfs_message_installroot
3. xfs_message_installnode
4. xfs_message_installattr
5. xfs_message_installdata
6. xfs_message_invalidnode
7. xfs_message_updatefid
8. gc_vnode
9. gc_vnode
10. xfs_message_gc_nodes
11. xfs_message_version

    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  */
   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>
RCSID("$arla: xfs_message.c,v 1.84 2003/06/02 18:25:20 lha Exp $");
   46 static void
send_inactive_node(int fd, xfs_handle *handle)
   48 {
   49     struct xfs_message_inactivenode msg;
msg.header.opcode = NNPFS_MSG_INACTIVENODE;
msg.handle = *handle;
msg.flag   = NNPFS_NOREFS | NNPFS_DELETE;
xfs_message_send(fd, &msg.header, sizeof(msg));
   55 }
   58 int
xfs_message_installroot(int fd,
   60                         struct xfs_message_installroot * message,
u_int size,
d_thread_t *p)
   63 {
   64     int error = 0;
NNPFSDEB(XDEBMSG, ("xfs_message_installroot (%d,%d,%d,%d)\n",
message->node.handle.a,
message->node.handle.b,
message->node.handle.c,
message->node.handle.d));
   72     if (xfs[fd].root != NULL) {
printf("NNPFS PANIC WARNING! xfs_message_installroot: called again!\n");
error = EBUSY;
   75     } else {
error = new_xfs_node(&xfs[fd], &message->node, &xfs[fd].root, p);
   77         if (error)
   78             return error;
NNPFS_MAKE_VROOT(xfs[fd].root->vn);
   80     }
   81     return error;
   82 }
   84 int
xfs_message_installnode(int fd,
   86                         struct xfs_message_installnode * message,
u_int size,
d_thread_t *p)
   89 {
   90     int error = 0;
   91     struct xfs_node *n, *dp;
NNPFSDEB(XDEBMSG, ("xfs_message_installnode (%d,%d,%d,%d)\n",
message->node.handle.a,
message->node.handle.b,
message->node.handle.c,
message->node.handle.d));
retry:
dp = xfs_node_find(&xfs[fd].nodehead, &message->parent_handle);
  101     if (dp) {
  102         struct vnode *t_vnode = XNODE_TO_VNODE(dp);
NNPFSDEB(XDEBMSG, ("xfs_message_installnode: t_vnode = %lx\n",
  105                            (unsigned long)t_vnode));
  107         if (xfs_do_vget(t_vnode, 0 /* LK_SHARED */, p))
  108                 goto retry;
error = new_xfs_node(&xfs[fd], &message->node, &n, p);
  111         if (error) {
vrele (t_vnode);
  113             return error;
  114         }
xfs_dnlc_enter_name(t_vnode,
message->name,
XNODE_TO_VNODE(n));
vrele (XNODE_TO_VNODE(n));
vrele (t_vnode);
  121     } else {
printf("NNPFS PANIC WARNING! xfs_message_installnode: no parent\n");
error = ENOENT;
  124     }
NNPFSDEB(XDEBMSG, ("return: xfs_message_installnode: %d\n", error));
  127     return error;
  128 }
  130 int
xfs_message_installattr(int fd,
  132                         struct xfs_message_installattr * message,
u_int size,
d_thread_t *p)
  135 {
  136     int error = 0;
  137     struct xfs_node *t;
NNPFSDEB(XDEBMSG, ("xfs_message_installattr (%d,%d,%d,%d) \n",
message->node.handle.a,
message->node.handle.b,
message->node.handle.c,
message->node.handle.d));
t = xfs_node_find(&xfs[fd].nodehead, &message->node.handle);
  146     if (t != 0) {
t->tokens = message->node.tokens;
  148         if ((t->tokens & NNPFS_DATA_MASK) && DATA_FROM_XNODE(t) == NULL) {
printf ("xfs_message_installattr: tokens and no data\n");
t->tokens &= ~NNPFS_DATA_MASK;
  151         }
xfs_attr2vattr(&message->node.attr, &t->attr, 0);
  153         if ((t->flags & NNPFS_VMOPEN) == 0)
xfs_set_vp_size(XNODE_TO_VNODE(t), t->attr.va_size);
bcopy(message->node.id, t->id, sizeof(t->id));
bcopy(message->node.rights, t->rights, sizeof(t->rights));
t->anonrights = message->node.anonrights;
  158     } else {
NNPFSDEB(XDEBMSG, ("xfs_message_installattr: no such node\n"));
  160     }
  162     return error;
  163 }
  165 int
xfs_message_installdata(int fd,
  167                         struct xfs_message_installdata * message,
u_int size,
d_thread_t *p)
  170 {
  171     struct xfs_node *t;
  172     int error = 0;
NNPFSDEB(XDEBMSG, ("xfs_message_installdata (%d,%d,%d,%d)\n",
message->node.handle.a,
message->node.handle.b,
message->node.handle.c,
message->node.handle.d));
retry:
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;
message->cache_name[sizeof(message->cache_name)-1] = '\0';
NNPFSDEB(XDEBMSG, ("cache_name = '%s'\n", message->cache_name));
  191         if (xfs_do_vget(t_vnode, 0 /* LK_SHARED */, p))
  192                 goto retry;
  194         if (message->flag & NNPFS_ID_HANDLE_VALID) {
error = xfs_fhlookup (p, fh, &vp);
  196         } else {
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
NNPFSDEB(XDEBMSG,
  208                    ("xfs_message_installdata: fhlookup failed: %d, "
  209                     "opening by name\n", error));
NDINIT(ndp, LOOKUP, FOLLOW | NNPFS_LOCKLEAF, UIO_SYSSPACE,
message->cache_name, p);
error = namei(ndp);
vp = ndp->ni_vp;
  215         }
  217         if (error == 0) {
  218 #ifndef __osf__
xfs_vfs_unlock(vp, p);
  220 #endif
  221             if (DATA_FROM_XNODE(t))
vrele(DATA_FROM_XNODE(t));
DATA_FROM_XNODE(t) = vp;
NNPFSDEB(XDEBMSG, ("xfs_message_installdata: t = %lx;"
  226                              " tokens = %x\n",
  227                              (unsigned long)t, message->node.tokens));
t->tokens = message->node.tokens;
xfs_attr2vattr(&message->node.attr, &t->attr, 1);
  231             if ((t->flags & NNPFS_VMOPEN) == 0)
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))
xfs_dnlc_purge (XNODE_TO_VNODE(t));
bcopy(message->node.id, t->id, sizeof(t->id));
bcopy(message->node.rights, t->rights, sizeof(t->rights));
t->anonrights = message->node.anonrights;
t->offset = message->offset;
  240 #if 0
  241             if (message->flag & NNPFS_ID_AFSDIR)
t->flags |= NNPFS_AFSDIR;
  243 #endif
  244         } else {
printf("NNPFS PANIC WARNING! xfs_message_installdata failed!\n");
printf("Reason: lookup failed on cache file '%s', error = %d\n",
message->cache_name, error);
  248         }
vrele (t_vnode);
  250     } else {
printf("NNPFS PANIC WARNING! xfs_message_installdata failed\n");
printf("Reason: No node to install the data into!\n");
error = ENOENT;
  254     }
  256     return error;
  257 }
  259 #ifdef __osf__
  260 #define xfs_writecount v_wrcnt
  261 #else
  262 #define xfs_writecount v_writecount
  263 #endif
  265 int
xfs_message_invalidnode(int fd,
  267                         struct xfs_message_invalidnode * message,
u_int size,
d_thread_t *p)
  270 {
  271     int error = 0;
  272     struct xfs_node *t;
NNPFSDEB(XDEBMSG, ("xfs_message_invalidnode (%d,%d,%d,%d)\n",
message->handle.a,
message->handle.b,
message->handle.c,
message->handle.d));
  280 #ifdef __APPLE__
retry:
  282 #endif
t = xfs_node_find(&xfs[fd].nodehead, &message->handle);
  284     if (t != 0) {
  285         struct vnode *vp = XNODE_TO_VNODE(t);
  287         /* If open for writing, return immediately. Last close:er wins! */
  288         if (vp->v_usecount >= 0 && vp->xfs_writecount >= 1)
  289             return 0;
  291 #ifdef __FreeBSD__
  292         {
vm_object_t obj = vp->v_object;
  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;
  303         }
  304 #endif /* __FreeBSD__ */
  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;
  312             if (UBCISVALID(vp) && !ubc_isinuse(vp, 1)) {
ubc_setsize(vp, 0);
vrele(vp);
  315             } else {
vrele(vp);
t->flags |= NNPFS_STALE;
  318                 return 0;
  319             }
  320 #else
t->flags |= NNPFS_STALE;
  322             return 0;
  323 #endif
  324         }
  326         if (DATA_FROM_XNODE(t)) {
vrele(DATA_FROM_XNODE(t));
DATA_FROM_XNODE(t) = (struct vnode *) 0;
  329         }
NNPFS_TOKEN_CLEAR(t, ~0,
NNPFS_OPEN_MASK | NNPFS_ATTR_MASK |
NNPFS_DATA_MASK | NNPFS_LOCK_MASK);
  333         /* Dir changed, must invalidate DNLC. */
  334         if (vp->v_type == VDIR)
xfs_dnlc_purge(vp);
  336         if (vp->v_usecount == 0) {
  337 #ifndef __osf__
NNPFSDEB(XDEBVNOPS, ("xfs_message_invalidnode: vrecycle\n"));
vrecycle(vp, p);
  340 #else
  341             /* XXX */
  342 #endif /* __osf__ */
  343         }
  344     } else {
NNPFSDEB(XDEBMSG, ("xfs_message_invalidnode: no such node\n"));
send_inactive_node(fd, &message->handle);
error = ENOENT;
  348     }
  350     return error;
  351 }
  353 int
xfs_message_updatefid(int fd,
  355                       struct xfs_message_updatefid * message,
u_int size,
d_thread_t *p)
  358 {
  359     int error = 0;
NNPFSDEB(XDEBMSG, ("xfs_message_updatefid (%d,%d,%d,%d) (%d,%d,%d,%d)\n",
message->old_handle.a,
message->old_handle.b,
message->old_handle.c,
message->old_handle.d,
message->new_handle.a,
message->new_handle.b,
message->new_handle.c,
message->new_handle.d));
error = xfs_update_handle(&xfs[fd].nodehead, 
  372                                 &message->old_handle,
  373                                 &message->new_handle);
  374     if (error)
printf ("NNPFS PANIC WARNING! xfs_message_updatefid: %d\n", error);
  376     return error;
  377 }
  379 #if __osf__
  381 /*
  382  * Try to clean out nodes for the userland daemon
  383  */
  385 static void
gc_vnode (struct vnode *vp,
d_thread_t *p)
  388 {
  389     /* This node is on the freelist */
  390     if (vp->v_usecount <= 0) {
  392         /*  DIAGNOSTIC */
  393         if (vp->v_usecount < 0) {
vprint("vrele: bad ref count", vp);
panic("vrele: ref cnt");
  396         }
NNPFSDEB(XDEBMSG, ("xfs_message_gc: success\n"));
vgone(vp, VX_NOSLEEP, NULL);
  401     } else {
NNPFSDEB(XDEBMSG, ("xfs_message_gc: used\n"));
  403     }
  405 }
  408 #else /* !__osf__ */
  410 /*
  411  * Try to clean out nodes for the userland daemon
  412  */
  414 static void
gc_vnode (struct vnode *vp,
d_thread_t *p)
  417 {
  418 #ifdef HAVE_SYS_MUTEX_H
mtx_lock(&vp->v_interlock);
  420 #else
simple_lock(&vp->v_interlock);
  422 #endif
  424     /* This node is on the freelist */
  425     if (vp->v_usecount <= 0) {
  426 #if __FreeBSD__
vm_object_t obj;
obj = vp->v_object;
  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
mtx_unlock(&vp->v_interlock);
  439 #else
simple_unlock (&vp->v_interlock);
  441 #endif
  442             return;
  443         }
  444 #endif /* __FreeBSD__ */
  446 #ifdef DIAGNOSTIC
  447         if (vp->v_usecount < 0 || vp->v_writecount != 0) {
vprint("vrele: bad ref count", vp);
panic("vrele: ref cnt");
  450         }
  451 #endif /* DIAGNOSTIC */
NNPFSDEB(XDEBMSG, ("xfs_message_gc: success\n"));
  455 #ifdef HAVE_KERNEL_VGONEL
vgonel (vp, p);
  457 #else
  458 #ifdef HAVE_SYS_MUTEX_H
mtx_unlock(&vp->v_interlock);
  460 #else
simple_unlock(&vp->v_interlock); 
  462 #endif
vgone (vp);
  464 #endif
  466     } else {
  467 #ifdef HAVE_SYS_MUTEX_H
mtx_unlock(&vp->v_interlock);
  469 #else
simple_unlock(&vp->v_interlock);
  471 #endif
NNPFSDEB(XDEBMSG, ("xfs_message_gc: used\n"));
  473     }
  475 }
  477 #endif
  479 int
xfs_message_gc_nodes(int fd,
  481                        struct xfs_message_gc_nodes *message,
u_int size,
d_thread_t *p)
  484 {
  485     struct xfs_node *node;
  486     int i;
NNPFSDEB(XDEBMSG, ("xfs_message_gc\n"));
  490     for (i = 0; i < message->len; i++) {
node = xfs_node_find (&xfs[fd].nodehead, &message->handle[i]);
  492         if (node)
gc_vnode(XNODE_TO_VNODE(node), p);
  494         else {
NNPFSDEB(XDEBMSG, ("xfs_message_gc_nodes: no such node\n"));
send_inactive_node(fd, &message->handle[i]);
  497         }
  498     }
  500     return 0;
  501 }
  504 /*
  505  * Probe what version of xfs this support
  506  */
  508 int
xfs_message_version(int fd,
  510                     struct xfs_message_version *message,
u_int size,
d_thread_t *p)
  513 {
  514     struct xfs_message_wakeup msg;
  515     int ret;
ret = NNPFS_VERSION;
msg.header.opcode = NNPFS_MSG_WAKEUP;
msg.sleepers_sequence_num = message->header.sequence_num;
msg.error = ret;
  523     return xfs_message_send(fd, 
  524                               (struct xfs_message_header *) &msg, sizeof(msg));
  525 }