The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/xfs/xfs_vnodeops-common.c

Version: -  FREEBSD  -  FREEBSD11  -  FREEBSD10  -  FREEBSD9  -  FREEBSD92  -  FREEBSD91  -  FREEBSD90  -  FREEBSD8  -  FREEBSD82  -  FREEBSD81  -  FREEBSD80  -  FREEBSD7  -  FREEBSD74  -  FREEBSD73  -  FREEBSD72  -  FREEBSD71  -  FREEBSD70  -  FREEBSD6  -  FREEBSD64  -  FREEBSD63  -  FREEBSD62  -  FREEBSD61  -  FREEBSD60  -  FREEBSD5  -  FREEBSD55  -  FREEBSD54  -  FREEBSD53  -  FREEBSD52  -  FREEBSD51  -  FREEBSD50  -  FREEBSD4  -  FREEBSD3  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

    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(*msg), M_TEMP, M_WAITOK | M_ZERO);
  935     if (msg == NULL) {
  936         error = ENOMEM;
  937         goto done;
  938     }
  939 
  940     msg->header.opcode = NNPFS_MSG_SYMLINK;
  941     msg->parent_handle = xn->handle;
  942     vattr2xfs_attr(vap, &msg->attr);
  943     msg->cred.uid = cred->cr_uid;
  944     msg->cred.pag = xfs_get_pag(cred);
  945     if (strlcpy (msg->contents, target, sizeof(msg->contents)) >= NNPFS_MAX_SYMLINK_CONTENT) {
  946         error = ENAMETOOLONG;
  947         goto done;
  948     }
  949     if (strlcpy(msg->name, name, sizeof(msg->name)) >= NNPFS_MAX_NAME) {
  950         error = ENAMETOOLONG;
  951         goto done;
  952     }
  953     error = xfs_message_rpc(xfsp->fd, &msg->header, sizeof(*msg), proc);
  954     if (error == 0)
  955         error = ((struct xfs_message_wakeup *) msg)->error;
  956 
  957  done:
  958     free(msg, M_TEMP);
  959     return error;
  960 }
  961 
  962 int
  963 xfs_readlink_common(struct vnode *vp, struct uio *uiop, struct ucred *cred)
  964 {
  965     int error = 0;
  966 
  967     NNPFSDEB(XDEBVNOPS, ("xfs_readlink\n"));
  968 
  969 #ifdef HAVE_FREEBSD_THREAD
  970     error = xfs_data_valid(vp, cred, xfs_uio_to_thread(uiop), NNPFS_DATA_R,
  971                            xfs_uio_end_length(uiop));
  972 #else
  973     error = xfs_data_valid(vp, cred, xfs_uio_to_proc(uiop), NNPFS_DATA_R,
  974                            xfs_uio_end_length(uiop));
  975 #endif
  976     if (error == 0) {
  977         struct vnode *t = DATA_FROM_VNODE(vp);
  978 
  979 #ifdef HAVE_FREEBSD_THREAD
  980         xfs_vfs_readlock(t, xfs_uio_to_thread(uiop));
  981         xfs_vop_read(t, uiop, 0, cred, error);
  982         xfs_vfs_unlock(t, xfs_uio_to_thread(uiop));
  983 #else
  984         xfs_vfs_readlock(t, xfs_uio_to_proc(uiop));
  985         xfs_vop_read(t, uiop, 0, cred, error);
  986         xfs_vfs_unlock(t, xfs_uio_to_proc(uiop));
  987 #endif
  988     }
  989     return error;
  990 }
  991 
  992 int
  993 xfs_inactive_common(struct vnode *vp, d_thread_t *p)
  994 {
  995     int error;
  996     struct xfs_node *xn = VNODE_TO_XNODE(vp);
  997 
  998     NNPFSDEB(XDEBVNOPS, ("xfs_inactive, %lx\n",
  999                        (unsigned long)vp));
 1000 
 1001     /*
 1002      * This seems rather bogus, but sometimes we get an already
 1003      * cleaned node to be made inactive.  Just ignoring it seems safe.
 1004      */
 1005 
 1006     if (xn == NULL) {
 1007         NNPFSDEB(XDEBVNOPS, ("xfs_inactive: clean node\n"));
 1008         return 0;
 1009     }
 1010 
 1011     /* xn->wr_cred not set -> NOCRED */
 1012 
 1013     if (vp->v_type == VREG)
 1014         xfs_pushdirty(vp, xn->wr_cred, p);
 1015 
 1016     error = xfs_fsync_common(vp, xn->wr_cred, /* XXX */ 0, p);
 1017     if (error) {
 1018         printf ("xfs_inactive: failed writing back data: %d\n", error);
 1019         xn->flags &= ~NNPFS_DATA_DIRTY;
 1020     }
 1021 
 1022     /* If this node is no longer valid, recycle immediately. */
 1023     if (!NNPFS_TOKEN_GOT(xn, NNPFS_ATTR_R | NNPFS_ATTR_W)
 1024         || (xn->flags & NNPFS_STALE) == NNPFS_STALE)
 1025     {
 1026 #ifndef __osf__
 1027         xfs_vfs_unlock(vp, p);
 1028         NNPFSDEB(XDEBVNOPS, ("xfs_inactive: vrecycle\n"));
 1029         vrecycle(vp, p);
 1030 #else /* __osf__ */
 1031         NNPFSDEB(XDEBVNOPS, ("xfs_inactive: vp = %lx vp->v_usecount= %d\n",
 1032                              (unsigned long)vp, vp?vp->v_usecount:0));
 1033 #endif /* __osf__ */
 1034     } else {
 1035 #ifndef __osf__
 1036         xfs_vfs_unlock(vp, p);
 1037 #endif
 1038         xn->flags &= ~NNPFS_STALE;
 1039     }
 1040 
 1041     NNPFSDEB(XDEBVNOPS, ("return: xfs_inactive\n"));
 1042 
 1043     return 0;
 1044 }
 1045 
 1046 int
 1047 xfs_reclaim_common(struct vnode *vp)
 1048 {
 1049     struct xfs_message_inactivenode msg;
 1050     struct xfs *xfsp = NNPFS_FROM_VNODE(vp);
 1051     struct xfs_node *xn = VNODE_TO_XNODE(vp);
 1052 
 1053     NNPFSDEB(XDEBVNOPS, ("xfs_reclaim: %lx\n",
 1054                        (unsigned long)vp));
 1055 
 1056     NNPFS_TOKEN_CLEAR(xn,
 1057                     ~0,
 1058                     NNPFS_OPEN_MASK | NNPFS_ATTR_MASK |
 1059                     NNPFS_DATA_MASK | NNPFS_LOCK_MASK);
 1060     /* Release, data if we still have it. */
 1061     if (DATA_FROM_XNODE(xn) != 0) {
 1062         vrele(DATA_FROM_XNODE(xn));
 1063         DATA_FROM_XNODE(xn) = 0;
 1064     }
 1065 
 1066     xfs_remove_node(&xfsp->nodehead, xn);
 1067 
 1068     msg.header.opcode = NNPFS_MSG_INACTIVENODE;
 1069     msg.handle = xn->handle;
 1070     msg.flag   = NNPFS_NOREFS | NNPFS_DELETE;
 1071     xfs_message_send(xfsp->fd, &msg.header, sizeof(msg));
 1072 
 1073     xfs_dnlc_purge(vp);
 1074     free_xfs_node(xn);
 1075     return 0;
 1076 }
 1077 
 1078 /*
 1079  *
 1080  */
 1081 
 1082 #if 0
 1083 
 1084 int
 1085 xfs_advlock_common(struct vnode *dvp, 
 1086                    int locktype,
 1087                    unsigned long lockid, /* XXX this good ? */
 1088                    struct ucred *cred)
 1089 {
 1090     struct xfs *xfsp = NNPFS_FROM_VNODE(dvp);
 1091     struct xfs_node *xn = VNODE_TO_XNODE(dvp);
 1092     int error = 0;
 1093 
 1094     NNPFSDEB(XDEBVNOPS, ("xfs_advlock\n"));
 1095     {
 1096         struct xfs_message_advlock msg;
 1097 
 1098         msg.header.opcode = NNPFS_MSG_ADVLOCK;
 1099         msg.handle = xn->handle;
 1100         msg.locktype = locktype;
 1101         msg.lockid = lockid;
 1102 
 1103         if (cred != NOCRED) {
 1104             msg.cred.uid = cred->cr_uid;
 1105             msg.cred.pag = xfs_get_pag(cred);
 1106         } else {
 1107             msg.cred.uid = 0;
 1108             msg.cred.pag = NNPFS_ANONYMOUSID;
 1109         }
 1110         error = xfs_message_rpc(xfsp->fd, &msg.header, sizeof(msg), p);
 1111         if (error == 0)
 1112             error = ((struct xfs_message_wakeup *) & msg)->error;
 1113     }
 1114 
 1115     if (error == 0) {
 1116         
 1117         /* sleep until woken */
 1118 
 1119     } else {
 1120 
 1121         /* die */
 1122     }
 1123 
 1124     return error;
 1125 }
 1126 
 1127 #endif
 1128 
 1129 /*
 1130  *
 1131  */
 1132 
 1133 void
 1134 xfs_printnode_common (struct vnode *vp)
 1135 {
 1136     struct xfs_node *xn = VNODE_TO_XNODE(vp);
 1137 
 1138     printf ("xnode: fid: %d.%d.%d.%d\n", 
 1139             xn->handle.a, xn->handle.b, xn->handle.c, xn->handle.d);
 1140     printf ("\tattr: %svalid\n", 
 1141             NNPFS_TOKEN_GOT(xn, NNPFS_ATTR_VALID) ? "": "in");
 1142     printf ("\tdata: %svalid\n", 
 1143             NNPFS_TOKEN_GOT(xn, NNPFS_DATA_VALID) ? "": "in");
 1144     printf ("\tflags: 0x%x\n", xn->flags);
 1145     printf ("\toffset: %d\n", xn->offset);
 1146 }

Cache object: 1041e9e23b7d9116678d324ab74aac5c


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.