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/fs/coda/coda_vnops.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  *             Coda: an Experimental Distributed File System
    3  *                              Release 3.1
    4  *
    5  *           Copyright (c) 1987-1998 Carnegie Mellon University
    6  *                          All Rights Reserved
    7  *
    8  * Permission  to  use, copy, modify and distribute this software and its
    9  * documentation is hereby granted,  provided  that  both  the  copyright
   10  * notice  and  this  permission  notice  appear  in  all  copies  of the
   11  * software, derivative works or  modified  versions,  and  any  portions
   12  * thereof, and that both notices appear in supporting documentation, and
   13  * that credit is given to Carnegie Mellon University  in  all  documents
   14  * and publicity pertaining to direct or indirect use of this code or its
   15  * derivatives.
   16  *
   17  * CODA IS AN EXPERIMENTAL SOFTWARE SYSTEM AND IS  KNOWN  TO  HAVE  BUGS,
   18  * SOME  OF  WHICH MAY HAVE SERIOUS CONSEQUENCES.  CARNEGIE MELLON ALLOWS
   19  * FREE USE OF THIS SOFTWARE IN ITS "AS IS" CONDITION.   CARNEGIE  MELLON
   20  * DISCLAIMS  ANY  LIABILITY  OF  ANY  KIND  FOR  ANY  DAMAGES WHATSOEVER
   21  * RESULTING DIRECTLY OR INDIRECTLY FROM THE USE OF THIS SOFTWARE  OR  OF
   22  * ANY DERIVATIVE WORK.
   23  *
   24  * Carnegie  Mellon  encourages  users  of  this  software  to return any
   25  * improvements or extensions that  they  make,  and  to  grant  Carnegie
   26  * Mellon the rights to redistribute these changes without encumbrance.
   27  *
   28  *      @(#) src/sys/coda/coda_vnops.c,v 1.1.1.1 1998/08/29 21:14:52 rvb Exp $
   29  */
   30 /*
   31  * Mach Operating System
   32  * Copyright (c) 1990 Carnegie-Mellon University
   33  * Copyright (c) 1989 Carnegie-Mellon University
   34  * All rights reserved.  The CMU software License Agreement specifies
   35  * the terms and conditions for use and redistribution.
   36  */
   37 
   38 /*
   39  * This code was written for the Coda filesystem at Carnegie Mellon
   40  * University.  Contributers include David Steere, James Kistler, and
   41  * M. Satyanarayanan.
   42  */
   43 
   44 #include <sys/cdefs.h>
   45 __FBSDID("$FreeBSD$");
   46 
   47 #include <sys/param.h>
   48 #include <sys/systm.h>
   49 #include <sys/acct.h>
   50 #include <sys/errno.h>
   51 #include <sys/fcntl.h>
   52 #include <sys/kernel.h>
   53 #include <sys/lock.h>
   54 #include <sys/malloc.h>
   55 #include <sys/file.h>           /* Must come after sys/malloc.h */
   56 #include <sys/mount.h>
   57 #include <sys/mutex.h>
   58 #include <sys/namei.h>
   59 #include <sys/proc.h>
   60 #include <sys/uio.h>
   61 #include <sys/unistd.h>
   62 
   63 #include <vm/vm.h>
   64 #include <vm/vm_object.h>
   65 #include <vm/vm_extern.h>
   66 
   67 #include <fs/coda/coda.h>
   68 #include <fs/coda/cnode.h>
   69 #include <fs/coda/coda_vnops.h>
   70 #include <fs/coda/coda_venus.h>
   71 #include <fs/coda/coda_opstats.h>
   72 #include <fs/coda/coda_subr.h>
   73 #include <fs/coda/coda_pioctl.h>
   74 
   75 /*
   76  * These flags select various performance enhancements.
   77  */
   78 static int coda_attr_cache = 1;         /* Set to cache attributes. */
   79 static int coda_symlink_cache = 1;      /* Set to cache symbolic links. */
   80 static int coda_access_cache = 1;       /* Set to cache some access checks. */
   81 
   82 /*
   83  * Structure to keep track of vfs calls.
   84  */
   85 static struct coda_op_stats coda_vnodeopstats[CODA_VNODEOPS_SIZE];
   86 
   87 #define MARK_ENTRY(op)          (coda_vnodeopstats[op].entries++)
   88 #define MARK_INT_SAT(op)        (coda_vnodeopstats[op].sat_intrn++)
   89 #define MARK_INT_FAIL(op)       (coda_vnodeopstats[op].unsat_intrn++)
   90 #define MARK_INT_GEN(op)        (coda_vnodeopstats[op].gen_intrn++)
   91 
   92 /*
   93  * What we are delaying for in printf.
   94  */
   95 int coda_printf_delay = 0;      /* In microseconds */
   96 int coda_vnop_print_entry = 0;
   97 static int coda_lockdebug = 0;
   98 
   99 /*
  100  * Some FreeBSD details:
  101  *
  102  * codadev_modevent is called at boot time or module load time.
  103  */
  104 #define ENTRY do {                                                      \
  105         if (coda_vnop_print_entry)                                      \
  106                 myprintf(("Entered %s\n", __func__));                   \
  107 } while (0)
  108 
  109 /*
  110  * Definition of the vnode operation vector.
  111  */
  112 struct vop_vector coda_vnodeops = {
  113         .vop_default = &default_vnodeops,
  114         .vop_cachedlookup = coda_lookup,        /* uncached lookup */
  115         .vop_lookup = vfs_cache_lookup,         /* namecache lookup */
  116         .vop_create = coda_create,              /* create */
  117         .vop_open = coda_open,                  /* open */
  118         .vop_close = coda_close,                /* close */
  119         .vop_access = coda_access,              /* access */
  120         .vop_getattr = coda_getattr,            /* getattr */
  121         .vop_setattr = coda_setattr,            /* setattr */
  122         .vop_read = coda_read,                  /* read */
  123         .vop_write = coda_write,                /* write */
  124         .vop_ioctl = coda_ioctl,                /* ioctl */
  125         .vop_fsync = coda_fsync,                /* fsync */
  126         .vop_remove = coda_remove,              /* remove */
  127         .vop_link = coda_link,                  /* link */
  128         .vop_rename = coda_rename,              /* rename */
  129         .vop_mkdir = coda_mkdir,                /* mkdir */
  130         .vop_rmdir = coda_rmdir,                /* rmdir */
  131         .vop_symlink = coda_symlink,            /* symlink */
  132         .vop_readdir = coda_readdir,            /* readdir */
  133         .vop_readlink = coda_readlink,          /* readlink */
  134         .vop_inactive = coda_inactive,          /* inactive */
  135         .vop_reclaim = coda_reclaim,            /* reclaim */
  136         .vop_lock1 = coda_lock,                 /* lock */
  137         .vop_unlock = coda_unlock,              /* unlock */
  138         .vop_bmap = VOP_EOPNOTSUPP,             /* bmap */
  139         .vop_print = VOP_NULL,                  /* print */
  140         .vop_islocked = coda_islocked,          /* islocked */
  141         .vop_pathconf = coda_pathconf,          /* pathconf */
  142         .vop_poll = vop_stdpoll,
  143         .vop_getpages = vop_stdgetpages,        /* pager intf.*/
  144         .vop_putpages = vop_stdputpages,        /* pager intf.*/
  145         .vop_getwritemount = vop_stdgetwritemount,
  146 #if 0
  147         /* missing */
  148         .vop_cachedlookup = ufs_lookup,
  149         .vop_whiteout = ufs_whiteout,
  150 #endif
  151 
  152 };
  153 
  154 static void     coda_print_vattr(struct vattr *attr);
  155 
  156 int
  157 coda_vnodeopstats_init(void)
  158 {
  159         int i;
  160 
  161         for(i=0; i<CODA_VNODEOPS_SIZE; i++) {
  162                 coda_vnodeopstats[i].opcode = i;
  163                 coda_vnodeopstats[i].entries = 0;
  164                 coda_vnodeopstats[i].sat_intrn = 0;
  165                 coda_vnodeopstats[i].unsat_intrn = 0;
  166                 coda_vnodeopstats[i].gen_intrn = 0;
  167         }
  168         return (0);
  169 }
  170 
  171 /*
  172  * coda_open calls Venus which returns an open file descriptor the cache file
  173  * holding the data.  We get the vnode while we are still in the context of
  174  * the venus process in coda_psdev.c.  This vnode is then passed back to the
  175  * caller and opened.
  176  */
  177 int
  178 coda_open(struct vop_open_args *ap)
  179 {
  180 
  181         /*
  182          * FreeBSD can pass the O_EXCL flag in mode, even though the check
  183          * has already happened.  Venus defensively assumes that if open is
  184          * passed the EXCL, it must be a bug.  We strip the flag here.
  185          */
  186         /* true args */
  187         struct vnode **vpp = &(ap->a_vp);
  188         struct cnode *cp = VTOC(*vpp);
  189         int flag = ap->a_mode & (~O_EXCL);
  190         struct ucred *cred = ap->a_cred;
  191         struct thread *td = ap->a_td;
  192         /* locals */
  193         int error;
  194         struct vnode *vp;
  195 
  196         MARK_ENTRY(CODA_OPEN_STATS);
  197 
  198         /*
  199          * Check for open of control file.
  200          */
  201         if (IS_CTL_VP(*vpp)) {
  202                 /* XXX */
  203                 /* if (WRITEABLE(flag)) */
  204                 if (flag & (FWRITE | O_TRUNC | O_CREAT | O_EXCL)) {
  205                         MARK_INT_FAIL(CODA_OPEN_STATS);
  206                         return (EACCES);
  207                 }
  208                 MARK_INT_SAT(CODA_OPEN_STATS);
  209                 return (0);
  210         }
  211         error = venus_open(vtomi((*vpp)), &cp->c_fid, flag, cred,
  212             td->td_proc, &vp);
  213         if (error)
  214                 return (error);
  215         CODADEBUG(CODA_OPEN, myprintf(("open: vp %p result %d\n", vp,
  216             error)););
  217 
  218         /*
  219          * Save the vnode pointer for the cache file.
  220          */
  221         if (cp->c_ovp == NULL) {
  222                 cp->c_ovp = vp;
  223         } else {
  224                 if (cp->c_ovp != vp)
  225                         panic("coda_open: cp->c_ovp != ITOV(ip)");
  226         }
  227         cp->c_ocount++;
  228 
  229         /*
  230          * Flush the attribute cached if writing the file.
  231          */
  232         if (flag & FWRITE) {
  233                 cp->c_owrite++;
  234                 cp->c_flags &= ~C_VATTR;
  235         }
  236 
  237         /*
  238          * Open the cache file.
  239          */
  240         vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
  241         error = VOP_OPEN(vp, flag, cred, td, NULL);
  242         if (error) {
  243                 VOP_UNLOCK(vp, 0);
  244                 printf("coda_open: VOP_OPEN on container failed %d\n", error);
  245                 return (error);
  246         }
  247         (*vpp)->v_object = vp->v_object;
  248         VOP_UNLOCK(vp, 0);
  249         return (0);
  250 }
  251 
  252 /*
  253  * Close the cache file used for I/O and notify Venus.
  254  */
  255 int
  256 coda_close(struct vop_close_args *ap)
  257 {
  258         /* true args */
  259         struct vnode *vp = ap->a_vp;
  260         struct cnode *cp = VTOC(vp);
  261         int flag = ap->a_fflag;
  262         struct ucred *cred = ap->a_cred;
  263         struct thread *td = ap->a_td;
  264         /* locals */
  265         int error;
  266 
  267         MARK_ENTRY(CODA_CLOSE_STATS);
  268 
  269         /*
  270          * Check for close of control file.
  271          */
  272         if (IS_CTL_VP(vp)) {
  273                 MARK_INT_SAT(CODA_CLOSE_STATS);
  274                 return (0);
  275         }
  276         if (cp->c_ovp) {
  277                 vn_lock(cp->c_ovp, LK_EXCLUSIVE | LK_RETRY);
  278                 /* Do errors matter here? */
  279                 VOP_CLOSE(cp->c_ovp, flag, cred, td);
  280                 vput(cp->c_ovp);
  281         }
  282 #ifdef CODA_VERBOSE
  283         else
  284                 printf("coda_close: NO container vp %p/cp %p\n", vp, cp);
  285 #endif
  286         if (--cp->c_ocount == 0)
  287                 cp->c_ovp = NULL;
  288 
  289         /*
  290          * File was opened for write.
  291          */
  292         if (flag & FWRITE)
  293                 --cp->c_owrite;
  294         if (!IS_UNMOUNTING(cp))
  295                 error = venus_close(vtomi(vp), &cp->c_fid, flag, cred,
  296                     td->td_proc);
  297         else
  298                 error = ENODEV;
  299         CODADEBUG(CODA_CLOSE, myprintf(("close: result %d\n",error)););
  300         return (error);
  301 }
  302 
  303 int
  304 coda_read(struct vop_read_args *ap)
  305 {
  306 
  307         ENTRY;
  308         return (coda_rdwr(ap->a_vp, ap->a_uio, UIO_READ, ap->a_ioflag,
  309             ap->a_cred, ap->a_uio->uio_td));
  310 }
  311 
  312 int
  313 coda_write(struct vop_write_args *ap)
  314 {
  315 
  316         ENTRY;
  317         return (coda_rdwr(ap->a_vp, ap->a_uio, UIO_WRITE, ap->a_ioflag,
  318             ap->a_cred, ap->a_uio->uio_td));
  319 }
  320 
  321 int
  322 coda_rdwr(struct vnode *vp, struct uio *uiop, enum uio_rw rw, int ioflag,
  323     struct ucred *cred, struct thread *td)
  324 {
  325         /* upcall decl */
  326         /* NOTE: container file operation!!! */
  327         /* locals */
  328         struct cnode *cp = VTOC(vp);
  329         struct vnode *cfvp = cp->c_ovp;
  330         int opened_internally = 0;
  331         int error = 0;
  332 
  333         MARK_ENTRY(CODA_RDWR_STATS);
  334         CODADEBUG(CODA_RDWR, myprintf(("coda_rdwr(%d, %p, %zd, %lld, %d)\n",
  335             rw, (void *)uiop->uio_iov->iov_base, uiop->uio_resid,
  336             (long long)uiop->uio_offset, uiop->uio_segflg)););
  337 
  338         /*
  339          * Check for rdwr of control object.
  340          */
  341         if (IS_CTL_VP(vp)) {
  342                 MARK_INT_FAIL(CODA_RDWR_STATS);
  343                 return (EINVAL);
  344         }
  345 
  346         /*
  347          * If file is not already open this must be a page {read,write}
  348          * request and we should open it internally.
  349          */
  350         if (cfvp == NULL) {
  351                 opened_internally = 1;
  352                 MARK_INT_GEN(CODA_OPEN_STATS);
  353                 error = VOP_OPEN(vp, (rw == UIO_READ ? FREAD : FWRITE), cred,
  354                     td, NULL);
  355 #ifdef CODA_VERBOSE
  356                 printf("coda_rdwr: Internally Opening %p\n", vp);
  357 #endif
  358                 if (error) {
  359                         printf("coda_rdwr: VOP_OPEN on container failed "
  360                             "%d\n", error);
  361                         return (error);
  362                 }
  363                 cfvp = cp->c_ovp;
  364         }
  365 
  366         /*
  367          * Have UFS handle the call.
  368          */
  369         CODADEBUG(CODA_RDWR, myprintf(("indirect rdwr: fid = %s, refcnt = "
  370             "%d\n", coda_f2s(&cp->c_fid), CTOV(cp)->v_usecount)););
  371         vn_lock(cfvp, LK_EXCLUSIVE | LK_RETRY);
  372         if (rw == UIO_READ) {
  373                 error = VOP_READ(cfvp, uiop, ioflag, cred);
  374         } else {
  375                 error = VOP_WRITE(cfvp, uiop, ioflag, cred);
  376                 /*
  377                  * ufs_write updates the vnode_pager_setsize for the
  378                  * vnode/object.
  379                  *
  380                  * XXX: Since we now share vm objects between layers, this is
  381                  * probably unnecessary.
  382                  */
  383                 {
  384                         struct vattr attr;
  385                         if (VOP_GETATTR(cfvp, &attr, cred) == 0)
  386                                 vnode_pager_setsize(vp, attr.va_size);
  387                 }
  388         }
  389         VOP_UNLOCK(cfvp, 0);
  390         if (error)
  391                 MARK_INT_FAIL(CODA_RDWR_STATS);
  392         else
  393                 MARK_INT_SAT(CODA_RDWR_STATS);
  394 
  395         /*
  396          * Do an internal close if necessary.
  397          */
  398         if (opened_internally) {
  399                 MARK_INT_GEN(CODA_CLOSE_STATS);
  400                 (void)VOP_CLOSE(vp, (rw == UIO_READ ? FREAD : FWRITE), cred,
  401                     td);
  402         }
  403 
  404         /*
  405          * Invalidate cached attributes if writing.
  406          */
  407         if (rw == UIO_WRITE)
  408                 cp->c_flags &= ~C_VATTR;
  409         return (error);
  410 }
  411 
  412 int
  413 coda_ioctl(struct vop_ioctl_args *ap)
  414 {
  415         /* true args */
  416         struct vnode *vp = ap->a_vp;
  417         int com = ap->a_command;
  418         caddr_t data = ap->a_data;
  419         int flag = ap->a_fflag;
  420         struct ucred *cred = ap->a_cred;
  421         struct thread *td = ap->a_td;
  422         /* locals */
  423         int error;
  424         struct vnode *tvp;
  425         struct nameidata ndp;
  426         struct PioctlData *iap = (struct PioctlData *)data;
  427 
  428         MARK_ENTRY(CODA_IOCTL_STATS);
  429         CODADEBUG(CODA_IOCTL, myprintf(("in coda_ioctl on %s\n", iap->path)););
  430 
  431         /*
  432          * Don't check for operation on a dying object, for ctlvp it
  433          * shouldn't matter.
  434          *
  435          * Must be control object to succeed.
  436          */
  437         if (!IS_CTL_VP(vp)) {
  438                 MARK_INT_FAIL(CODA_IOCTL_STATS);
  439                 CODADEBUG(CODA_IOCTL, myprintf(("coda_ioctl error: vp != "
  440                     "ctlvp")););
  441                 return (EOPNOTSUPP);
  442         }
  443 
  444         /*
  445          * Look up the pathname.
  446          *
  447          * Should we use the name cache here? It would get it from lookupname
  448          * sooner or later anyway, right?
  449          */
  450         NDINIT(&ndp, LOOKUP, (iap->follow ? FOLLOW : NOFOLLOW),
  451             UIO_USERSPACE, iap->path, td);
  452         error = namei(&ndp);
  453         tvp = ndp.ni_vp;
  454         if (error) {
  455                 MARK_INT_FAIL(CODA_IOCTL_STATS);
  456                 CODADEBUG(CODA_IOCTL, myprintf(("coda_ioctl error: lookup "
  457                     "returns %d\n", error)););
  458                 return (error);
  459         }
  460 
  461         /*
  462          * Make sure this is a coda style cnode, but it may be a different
  463          * vfsp.
  464          */
  465         if (tvp->v_op != &coda_vnodeops) {
  466                 vrele(tvp);
  467                 NDFREE(&ndp, NDF_ONLY_PNBUF);
  468                 MARK_INT_FAIL(CODA_IOCTL_STATS);
  469                 CODADEBUG(CODA_IOCTL,
  470                 myprintf(("coda_ioctl error: %s not a coda object\n",
  471                     iap->path)););
  472                 return (EINVAL);
  473         }
  474         if (iap->vi.in_size > VC_MAXDATASIZE ||
  475             iap->vi.out_size > VC_MAXDATASIZE) {
  476                 NDFREE(&ndp, 0);
  477                 return (EINVAL);
  478         }
  479         error = venus_ioctl(vtomi(tvp), &((VTOC(tvp))->c_fid), com, flag,
  480             data, cred, td->td_proc);
  481         if (error)
  482                 MARK_INT_FAIL(CODA_IOCTL_STATS);
  483         else
  484                 CODADEBUG(CODA_IOCTL, myprintf(("Ioctl returns %d \n",
  485                     error)););
  486         vrele(tvp);
  487         NDFREE(&ndp, NDF_ONLY_PNBUF);
  488         return (error);
  489 }
  490 
  491 /*
  492  * To reduce the cost of a user-level venus;we cache attributes in the
  493  * kernel.  Each cnode has storage allocated for an attribute.  If c_vattr is
  494  * valid, return a reference to it.  Otherwise, get the attributes from venus
  495  * and store them in the cnode.  There is some question if this method is a
  496  * security leak.  But I think that in order to make this call, the user must
  497  * have done a lookup and opened the file, and therefore should already have
  498  * access.
  499  */
  500 int
  501 coda_getattr(struct vop_getattr_args *ap)
  502 {
  503         /* true args */
  504         struct vnode *vp = ap->a_vp;
  505         struct cnode *cp = VTOC(vp);
  506         struct vattr *vap = ap->a_vap;
  507         struct ucred *cred = ap->a_cred;
  508         /* locals */
  509         struct vnode *convp;
  510         int error, size;
  511 
  512         MARK_ENTRY(CODA_GETATTR_STATS);
  513         if (IS_UNMOUNTING(cp))
  514                 return (ENODEV);
  515 
  516         /*
  517          * Check for getattr of control object.
  518          */
  519         if (IS_CTL_VP(vp)) {
  520                 MARK_INT_FAIL(CODA_GETATTR_STATS);
  521                 return (ENOENT);
  522         }
  523 
  524         /*
  525          * Check to see if the attributes have already been cached.
  526          */
  527         if (VALID_VATTR(cp)) {
  528                 CODADEBUG(CODA_GETATTR, myprintf(("attr cache hit: %s\n",
  529                     coda_f2s(&cp->c_fid))););
  530                 CODADEBUG(CODA_GETATTR, if (!(codadebug & ~CODA_GETATTR))
  531                     coda_print_vattr(&cp->c_vattr););
  532                 *vap = cp->c_vattr;
  533                 MARK_INT_SAT(CODA_GETATTR_STATS);
  534                 return (0);
  535         }
  536         error = venus_getattr(vtomi(vp), &cp->c_fid, cred, vap);
  537         if (!error) {
  538                 CODADEBUG(CODA_GETATTR, myprintf(("getattr miss %s: result "
  539                     "%d\n", coda_f2s(&cp->c_fid), error)););
  540                 CODADEBUG(CODA_GETATTR, if (!(codadebug & ~CODA_GETATTR))
  541                     coda_print_vattr(vap););
  542 
  543                 /*
  544                  * XXX: Since we now share vm objects between layers, this is
  545                  * probably unnecessary.
  546                  */
  547                 size = vap->va_size;
  548                 convp = cp->c_ovp;
  549                 if (convp != NULL)
  550                         vnode_pager_setsize(convp, size);
  551 
  552                 /*
  553                  * If not open for write, store attributes in cnode.
  554                  */
  555                 if ((cp->c_owrite == 0) && (coda_attr_cache)) {
  556                         cp->c_vattr = *vap;
  557                         cp->c_flags |= C_VATTR;
  558                 }
  559         }
  560         return (error);
  561 }
  562 
  563 int
  564 coda_setattr(struct vop_setattr_args *ap)
  565 {
  566         /* true args */
  567         struct vnode *vp = ap->a_vp;
  568         struct cnode *cp = VTOC(vp);
  569         struct vattr *vap = ap->a_vap;
  570         struct ucred *cred = ap->a_cred;
  571         /* locals */
  572         struct vnode *convp;
  573         int error, size;
  574 
  575         MARK_ENTRY(CODA_SETATTR_STATS);
  576 
  577         /*
  578          * Check for setattr of control object.
  579          */
  580         if (IS_CTL_VP(vp)) {
  581                 MARK_INT_FAIL(CODA_SETATTR_STATS);
  582                 return (ENOENT);
  583         }
  584         if (codadebug & CODADBGMSK(CODA_SETATTR))
  585                 coda_print_vattr(vap);
  586         error = venus_setattr(vtomi(vp), &cp->c_fid, vap, cred);
  587         if (!error)
  588                 cp->c_flags &= ~(C_VATTR | C_ACCCACHE);
  589 
  590         /*
  591          * XXX: Since we now share vm objects between layers, this is
  592          * probably unnecessary.
  593          *
  594          * XXX: Shouldn't we only be doing this "set" if C_VATTR remains
  595          * valid after venus_setattr()?
  596          */
  597         size = vap->va_size;
  598         convp = cp->c_ovp;
  599         if (size != VNOVAL && convp != NULL)
  600                 vnode_pager_setsize(convp, size);
  601         CODADEBUG(CODA_SETATTR, myprintf(("setattr %d\n", error)););
  602         return (error);
  603 }
  604 
  605 int
  606 coda_access(struct vop_access_args *ap)
  607 {
  608         /* true args */
  609         struct vnode *vp = ap->a_vp;
  610         struct cnode *cp = VTOC(vp);
  611         accmode_t accmode = ap->a_accmode;
  612         struct ucred *cred = ap->a_cred;
  613         struct thread *td = ap->a_td;
  614         /* locals */
  615         int error;
  616 
  617         MARK_ENTRY(CODA_ACCESS_STATS);
  618 
  619         /*
  620          * Check for access of control object.  Only read access is allowed
  621          * on it.
  622          */
  623         if (IS_CTL_VP(vp)) {
  624                 /*
  625                  * Bogus hack - all will be marked as successes.
  626                  */
  627                 MARK_INT_SAT(CODA_ACCESS_STATS);
  628                 return (((accmode & VREAD) && !(accmode & (VWRITE | VEXEC)))
  629                     ? 0 : EACCES);
  630         }
  631 
  632         /*
  633          * We maintain a one-entry LRU positive access cache with each cnode.
  634          * In principle we could also track negative results, and for more
  635          * than one uid, but we don't yet.  Venus is responsible for
  636          * invalidating this cache as required.
  637          */
  638         if (coda_access_cache && VALID_ACCCACHE(cp) &&
  639             (cred->cr_uid == cp->c_cached_uid) &&
  640             (accmode & cp->c_cached_mode) == accmode) {
  641                 MARK_INT_SAT(CODA_ACCESS_STATS);
  642                 return (0);
  643         }
  644         error = venus_access(vtomi(vp), &cp->c_fid, accmode, cred, td->td_proc);
  645         if (error == 0 && coda_access_cache) {
  646                 /*-
  647                  * When we have a new successful request, we consider three
  648                  * cases:
  649                  *
  650                  * - No initialized access cache, in which case cache the
  651                  *   result.
  652                  * - Cached result for a different user, in which case we
  653                  *   replace the entry.
  654                  * - Cached result for the same user, in which case we add
  655                  *   any newly granted rights to the cached mode.
  656                  *
  657                  * XXXRW: If we ever move to something more interesting than
  658                  * uid-based token lookup, we'll need to change this.
  659                  */
  660                 cp->c_flags |= C_ACCCACHE;
  661                 if (cp->c_cached_uid != cred->cr_uid) {
  662                         cp->c_cached_mode = accmode;
  663                         cp->c_cached_uid = cred->cr_uid;
  664                 } else
  665                         cp->c_cached_mode |= accmode;
  666         }
  667         return (error);
  668 }
  669 
  670 int
  671 coda_readlink(struct vop_readlink_args *ap)
  672 {
  673         /* true args */
  674         struct vnode *vp = ap->a_vp;
  675         struct cnode *cp = VTOC(vp);
  676         struct uio *uiop = ap->a_uio;
  677         struct ucred *cred = ap->a_cred;
  678         struct thread *td = ap->a_uio->uio_td;
  679         /* locals */
  680         int error;
  681         char *str;
  682         int len;
  683 
  684         MARK_ENTRY(CODA_READLINK_STATS);
  685 
  686         /*
  687          * Check for readlink of control object.
  688          */
  689         if (IS_CTL_VP(vp)) {
  690                 MARK_INT_FAIL(CODA_READLINK_STATS);
  691                 return (ENOENT);
  692         }
  693         if ((coda_symlink_cache) && (VALID_SYMLINK(cp))) {
  694                 /*
  695                  * Symlink was cached.
  696                  */
  697                 uiop->uio_rw = UIO_READ;
  698                 error = uiomove(cp->c_symlink, (int)cp->c_symlen, uiop);
  699                 if (error)
  700                         MARK_INT_FAIL(CODA_READLINK_STATS);
  701                 else
  702                         MARK_INT_SAT(CODA_READLINK_STATS);
  703                 return (error);
  704         }
  705         error = venus_readlink(vtomi(vp), &cp->c_fid, cred, td != NULL ?
  706             td->td_proc : NULL, &str, &len);
  707         if (!error) {
  708                 uiop->uio_rw = UIO_READ;
  709                 error = uiomove(str, len, uiop);
  710                 if (coda_symlink_cache) {
  711                         cp->c_symlink = str;
  712                         cp->c_symlen = len;
  713                         cp->c_flags |= C_SYMLINK;
  714                 } else
  715                         CODA_FREE(str, len);
  716         }
  717         CODADEBUG(CODA_READLINK, myprintf(("in readlink result %d\n",
  718             error)););
  719         return (error);
  720 }
  721 
  722 int
  723 coda_fsync(struct vop_fsync_args *ap)
  724 {
  725         /* true args */
  726         struct vnode *vp = ap->a_vp;
  727         struct cnode *cp = VTOC(vp);
  728         struct thread *td = ap->a_td;
  729         /* locals */
  730         struct vnode *convp = cp->c_ovp;
  731         int error;
  732 
  733         MARK_ENTRY(CODA_FSYNC_STATS);
  734 
  735         /*
  736          * Check for fsync on an unmounting object.
  737          *
  738          * XXX: Is this comment true on FreeBSD?  It seems likely, since
  739          * unmounting is fairly non-atomic.
  740          *
  741          * The NetBSD kernel, in it's infinite wisdom, can try to fsync after
  742          * an unmount has been initiated.  This is a Bad Thing, which we have
  743          * to avoid.  Not a legitimate failure for stats.
  744          */
  745         if (IS_UNMOUNTING(cp))
  746                 return (ENODEV);
  747 
  748         /*
  749          * Check for fsync of control object.
  750          */
  751         if (IS_CTL_VP(vp)) {
  752                 MARK_INT_SAT(CODA_FSYNC_STATS);
  753                 return (0);
  754         }
  755         if (convp != NULL) {
  756                 vn_lock(convp, LK_EXCLUSIVE | LK_RETRY);
  757                 VOP_FSYNC(convp, MNT_WAIT, td);
  758                 VOP_UNLOCK(convp, 0);
  759         }
  760 
  761         /*
  762          * We see fsyncs with usecount == 1 then usecount == 0.  For now we
  763          * ignore them.
  764          */
  765 #if 0
  766         VI_LOCK(vp);
  767         if (!vp->v_usecount) {
  768                 printf("coda_fsync on vnode %p with %d usecount.  "
  769                     "c_flags = %x (%x)\n", vp, vp->v_usecount, cp->c_flags,
  770                     cp->c_flags&C_PURGING);
  771         }
  772         VI_UNLOCK(vp);
  773 #endif
  774 
  775         /*
  776          * We can expect fsync on any vnode at all if venus is purging it.
  777          * Venus can't very well answer the fsync request, now can it?
  778          * Hopefully, it won't have to, because hopefully, venus preserves
  779          * the (possibly untrue) invariant that it never purges an open
  780          * vnode.  Hopefully.
  781          */
  782         if (cp->c_flags & C_PURGING)
  783                 return (0);
  784 
  785         /* XXX: needs research */
  786         return (0);
  787         error = venus_fsync(vtomi(vp), &cp->c_fid, td->td_proc);
  788         CODADEBUG(CODA_FSYNC, myprintf(("in fsync result %d\n", error)););
  789         return (error);
  790 }
  791 
  792 int
  793 coda_inactive(struct vop_inactive_args *ap)
  794 {
  795         /*
  796          * XXX - at the moment, inactive doesn't look at cred, and doesn't
  797          * have a proc pointer.  Oops.
  798          */
  799         /* true args */
  800         struct vnode *vp = ap->a_vp;
  801         struct cnode *cp = VTOC(vp);
  802         struct ucred *cred __attribute__((unused)) = NULL;
  803         struct thread *td __attribute__((unused)) = curthread;
  804         /* upcall decl */
  805         /* locals */
  806 
  807         /*
  808          * We don't need to send inactive to venus - DCS.
  809          */
  810         MARK_ENTRY(CODA_INACTIVE_STATS);
  811         CODADEBUG(CODA_INACTIVE, myprintf(("in inactive, %s, vfsp %p\n",
  812             coda_f2s(&cp->c_fid), vp->v_mount)););
  813         vp->v_object = NULL;
  814 
  815         /*
  816          * If an array has been allocated to hold the symlink, deallocate it.
  817          */
  818         if ((coda_symlink_cache) && (VALID_SYMLINK(cp))) {
  819                 if (cp->c_symlink == NULL)
  820                         panic("coda_inactive: null symlink pointer in cnode");
  821                 CODA_FREE(cp->c_symlink, cp->c_symlen);
  822                 cp->c_flags &= ~C_SYMLINK;
  823                 cp->c_symlen = 0;
  824         }
  825 
  826         /*
  827          * Remove it from the table so it can't be found.
  828          */
  829         coda_unsave(cp);
  830         if ((struct coda_mntinfo *)(vp->v_mount->mnt_data) == NULL) {
  831                 myprintf(("Help! vfsp->vfs_data was NULL, but vnode %p "
  832                     "wasn't dying\n", vp));
  833                 panic("badness in coda_inactive\n");
  834         }
  835         if (IS_UNMOUNTING(cp)) {
  836 #ifdef  DEBUG
  837                 printf("coda_inactive: IS_UNMOUNTING use %d: vp %p, cp %p\n",
  838                     vrefcnt(vp), vp, cp);
  839                 if (cp->c_ovp != NULL)
  840                         printf("coda_inactive: cp->ovp != NULL use %d: vp "
  841                             "%p, cp %p\n", vrefcnt(vp), vp, cp);
  842 #endif
  843         } else
  844                 vgone(vp);
  845         MARK_INT_SAT(CODA_INACTIVE_STATS);
  846         return (0);
  847 }
  848 
  849 /*
  850  * Remote filesystem operations having to do with directory manipulation.
  851  */
  852 
  853 /*
  854  * In FreeBSD, lookup returns the vnode locked.
  855  */
  856 int
  857 coda_lookup(struct vop_cachedlookup_args *ap)
  858 {
  859         /* true args */
  860         struct vnode *dvp = ap->a_dvp;
  861         struct cnode *dcp = VTOC(dvp);
  862         struct vnode **vpp = ap->a_vpp;
  863         /*
  864          * It looks as though ap->a_cnp->ni_cnd->cn_nameptr holds the rest of
  865          * the string to xlate, and that we must try to get at least
  866          * ap->a_cnp->ni_cnd->cn_namelen of those characters to macth.  I
  867          * could be wrong.
  868          */
  869         struct componentname  *cnp = ap->a_cnp;
  870         struct ucred *cred = cnp->cn_cred;
  871         struct thread *td = cnp->cn_thread;
  872         /* locals */
  873         struct cnode *cp;
  874         const char *nm = cnp->cn_nameptr;
  875         int len = cnp->cn_namelen;
  876         struct CodaFid VFid;
  877         int vtype;
  878         int error = 0;
  879 
  880         MARK_ENTRY(CODA_LOOKUP_STATS);
  881         CODADEBUG(CODA_LOOKUP, myprintf(("lookup: %s in %s\n", nm,
  882             coda_f2s(&dcp->c_fid))););
  883 
  884         /*
  885          * Check for lookup of control object.
  886          */
  887         if (IS_CTL_NAME(dvp, nm, len)) {
  888                 *vpp = coda_ctlvp;
  889                 vref(*vpp);
  890                 MARK_INT_SAT(CODA_LOOKUP_STATS);
  891                 goto exit;
  892         }
  893         if (len+1 > CODA_MAXNAMLEN) {
  894                 MARK_INT_FAIL(CODA_LOOKUP_STATS);
  895                 CODADEBUG(CODA_LOOKUP, myprintf(("name too long: lookup, "
  896                     "%s (%s)\n", coda_f2s(&dcp->c_fid), nm)););
  897                 *vpp = NULL;
  898                 error = EINVAL;
  899                 goto exit;
  900         }
  901 
  902         error = venus_lookup(vtomi(dvp), &dcp->c_fid, nm, len, cred,
  903             td->td_proc, &VFid, &vtype);
  904         if (error) {
  905                 MARK_INT_FAIL(CODA_LOOKUP_STATS);
  906                 CODADEBUG(CODA_LOOKUP, myprintf(("lookup error on %s "
  907                     "(%s)%d\n", coda_f2s(&dcp->c_fid), nm, error)););
  908                 *vpp = NULL;
  909         } else {
  910                 MARK_INT_SAT(CODA_LOOKUP_STATS);
  911                 CODADEBUG(CODA_LOOKUP, myprintf(("lookup: %s type %o "
  912                     "result %d\n", coda_f2s(&VFid), vtype, error)););
  913                 cp = make_coda_node(&VFid, dvp->v_mount, vtype);
  914                 *vpp = CTOV(cp);
  915 
  916                 /*
  917                  * Enter the new vnode in the namecache only if the top bit
  918                  * isn't set.
  919                  *
  920                  * And don't enter a new vnode for an invalid one!
  921                  */
  922                 if (!(vtype & CODA_NOCACHE) && (cnp->cn_flags & MAKEENTRY))
  923                         cache_enter(dvp, *vpp, cnp);
  924         }
  925 exit:
  926         /*
  927          * If we are creating, and this was the last name to be looked up,
  928          * and the error was ENOENT, then there really shouldn't be an error
  929          * and we can make the leaf NULL and return success.  Since this is
  930          * supposed to work under Mach as well as FreeBSD, we're leaving this
  931          * fn wrapped.  We also must tell lookup/namei that we need to save
  932          * the last component of the name.  (Create will have to free the
  933          * name buffer later...lucky us...).
  934          */
  935         if (((cnp->cn_nameiop == CREATE) || (cnp->cn_nameiop == RENAME))
  936             && (cnp->cn_flags & ISLASTCN) && (error == ENOENT)) {
  937                 error = EJUSTRETURN;
  938                 cnp->cn_flags |= SAVENAME;
  939                 *ap->a_vpp = NULL;
  940         }
  941 
  942         /*
  943          * If we are removing, and we are at the last element, and we found
  944          * it, then we need to keep the name around so that the removal will
  945          * go ahead as planned.  Unfortunately, this will probably also lock
  946          * the to-be-removed vnode, which may or may not be a good idea.
  947          * I'll have to look at the bits of coda_remove to make sure.  We'll
  948          * only save the name if we did in fact find the name, otherwise
  949          * coda_remove won't have a chance to free the pathname.
  950          */
  951         if ((cnp->cn_nameiop == DELETE) && (cnp->cn_flags & ISLASTCN)
  952             && !error)
  953                 cnp->cn_flags |= SAVENAME;
  954 
  955         /*
  956          * If the lookup went well, we need to (potentially?) unlock the
  957          * parent, and lock the child.  We are only responsible for checking
  958          * to see if the parent is supposed to be unlocked before we return.
  959          * We must always lock the child (provided there is one, and (the
  960          * parent isn't locked or it isn't the same as the parent.)  Simple,
  961          * huh?  We can never leave the parent locked unless we are ISLASTCN.
  962          */
  963         if (!error || (error == EJUSTRETURN)) {
  964                 if (cnp->cn_flags & ISDOTDOT) {
  965                         VOP_UNLOCK(dvp, 0);
  966                         /*
  967                          * The parent is unlocked.  As long as there is a
  968                          * child, lock it without bothering to check anything
  969                          * else.
  970                          */
  971                         if (*ap->a_vpp)
  972                                 vn_lock(*ap->a_vpp, LK_EXCLUSIVE | LK_RETRY);
  973                         vn_lock(dvp, LK_RETRY|LK_EXCLUSIVE);
  974                 } else {
  975                         /*
  976                          * The parent is locked, and may be the same as the
  977                          * child.  If different, go ahead and lock it.
  978                          */
  979                         if (*ap->a_vpp && (*ap->a_vpp != dvp))
  980                                 vn_lock(*ap->a_vpp, LK_EXCLUSIVE | LK_RETRY);
  981                 }
  982         } else {
  983                 /*
  984                  * If the lookup failed, we need to ensure that the leaf is
  985                  * NULL.
  986                  *
  987                  * Don't change any locking?
  988                  */
  989                 *ap->a_vpp = NULL;
  990         }
  991         return (error);
  992 }
  993 
  994 /*ARGSUSED*/
  995 int
  996 coda_create(struct vop_create_args *ap)
  997 {
  998         /* true args */
  999         struct vnode *dvp = ap->a_dvp;
 1000         struct cnode *dcp = VTOC(dvp);
 1001         struct vattr *va = ap->a_vap;
 1002         int exclusive = 1;
 1003         int mode = ap->a_vap->va_mode;
 1004         struct vnode **vpp = ap->a_vpp;
 1005         struct componentname  *cnp = ap->a_cnp;
 1006         struct ucred *cred = cnp->cn_cred;
 1007         struct thread *td = cnp->cn_thread;
 1008         /* locals */
 1009         int error;
 1010         struct cnode *cp;
 1011         const char *nm = cnp->cn_nameptr;
 1012         int len = cnp->cn_namelen;
 1013         struct CodaFid VFid;
 1014         struct vattr attr;
 1015 
 1016         MARK_ENTRY(CODA_CREATE_STATS);
 1017 
 1018         /*
 1019          * All creates are exclusive XXX.
 1020          *
 1021          * I'm assuming the 'mode' argument is the file mode bits XXX.
 1022          *
 1023          * Check for create of control object.
 1024          */
 1025         if (IS_CTL_NAME(dvp, nm, len)) {
 1026                 *vpp = (struct vnode *)0;
 1027                 MARK_INT_FAIL(CODA_CREATE_STATS);
 1028                 return (EACCES);
 1029         }
 1030         error = venus_create(vtomi(dvp), &dcp->c_fid, nm, len, exclusive,
 1031             mode, va, cred, td->td_proc, &VFid, &attr);
 1032         if (!error) {
 1033                 /*
 1034                  * If this is an exclusive create, panic if the file already
 1035                  * exists.
 1036                  *
 1037                  * Venus should have detected the file and reported EEXIST.
 1038                  */
 1039                 if ((exclusive == 1) && (coda_find(&VFid) != NULL))
 1040                         panic("cnode existed for newly created file!");
 1041                 cp = make_coda_node(&VFid, dvp->v_mount, attr.va_type);
 1042                 *vpp = CTOV(cp);
 1043 
 1044                 /*
 1045                  * Update va to reflect the new attributes.
 1046                  */
 1047                 (*va) = attr;
 1048 
 1049                 /*
 1050                  * Update the attribute cache and mark it as valid.
 1051                  */
 1052                 if (coda_attr_cache) {
 1053                         VTOC(*vpp)->c_vattr = attr;
 1054                         VTOC(*vpp)->c_flags |= C_VATTR;
 1055                 }
 1056 
 1057                 /*
 1058                  * Invalidate the parent's attr cache, the modification time
 1059                  * has changed.
 1060                  */
 1061                 VTOC(dvp)->c_flags &= ~C_VATTR;
 1062                 cache_enter(dvp, *vpp, cnp);
 1063                 CODADEBUG(CODA_CREATE, myprintf(("create: %s, result %d\n",
 1064                     coda_f2s(&VFid), error)););
 1065         } else {
 1066                 *vpp = (struct vnode *)0;
 1067                 CODADEBUG(CODA_CREATE, myprintf(("create error %d\n",
 1068                     error)););
 1069         }
 1070         if (!error) {
 1071                 if (cnp->cn_flags & MAKEENTRY)
 1072                         cache_enter(dvp, *vpp, cnp);
 1073                 if (cnp->cn_flags & LOCKLEAF)
 1074                         vn_lock(*ap->a_vpp, LK_EXCLUSIVE | LK_RETRY);
 1075         } else if (error == ENOENT) {
 1076                 /*
 1077                  * XXXRW: We only enter a negative entry if ENOENT is
 1078                  * returned, not other errors.  But will Venus invalidate dvp
 1079                  * properly in all cases when new files appear via the
 1080                  * network rather than a local operation?
 1081                  */
 1082                 if (cnp->cn_flags & MAKEENTRY)
 1083                         cache_enter(dvp, NULL, cnp);
 1084         }
 1085         return (error);
 1086 }
 1087 
 1088 int
 1089 coda_remove(struct vop_remove_args *ap)
 1090 {
 1091         /* true args */
 1092         struct vnode *vp = ap->a_vp;
 1093         struct vnode *dvp = ap->a_dvp;
 1094         struct cnode *cp = VTOC(dvp);
 1095         struct componentname  *cnp = ap->a_cnp;
 1096         struct ucred *cred = cnp->cn_cred;
 1097         struct thread *td = cnp->cn_thread;
 1098         /* locals */
 1099         int error;
 1100         const char *nm = cnp->cn_nameptr;
 1101         int len = cnp->cn_namelen;
 1102 #if 0
 1103         struct cnode *tp;
 1104 #endif
 1105 
 1106         MARK_ENTRY(CODA_REMOVE_STATS);
 1107         CODADEBUG(CODA_REMOVE, myprintf(("remove: %s in %s\n", nm,
 1108             coda_f2s(&cp->c_fid))););
 1109 
 1110         /*
 1111          * Check for remove of control object.
 1112          */
 1113         if (IS_CTL_NAME(dvp, nm, len)) {
 1114                 MARK_INT_FAIL(CODA_REMOVE_STATS);
 1115                 return (ENOENT);
 1116         }
 1117 
 1118         /*
 1119          * Invalidate the parent's attr cache, the modification time has
 1120          * changed.  We don't yet know if the last reference to the file is
 1121          * being removed, but we do know the reference count on the child has
 1122          * changed, so invalidate its attr cache also.
 1123          */
 1124         VTOC(dvp)->c_flags &= ~C_VATTR;
 1125         VTOC(vp)->c_flags &= ~(C_VATTR | C_ACCCACHE);
 1126         error = venus_remove(vtomi(dvp), &cp->c_fid, nm, len, cred,
 1127             td->td_proc);
 1128         cache_purge(vp);
 1129         CODADEBUG(CODA_REMOVE, myprintf(("in remove result %d\n",error)););
 1130         return (error);
 1131 }
 1132 
 1133 int
 1134 coda_link(struct vop_link_args *ap)
 1135 {
 1136         /* true args */
 1137         struct vnode *vp = ap->a_vp;
 1138         struct cnode *cp = VTOC(vp);
 1139         struct vnode *tdvp = ap->a_tdvp;
 1140         struct cnode *tdcp = VTOC(tdvp);
 1141         struct componentname *cnp = ap->a_cnp;
 1142         struct ucred *cred = cnp->cn_cred;
 1143         struct thread *td = cnp->cn_thread;
 1144         /* locals */
 1145         int error;
 1146         const char *nm = cnp->cn_nameptr;
 1147         int len = cnp->cn_namelen;
 1148 
 1149         MARK_ENTRY(CODA_LINK_STATS);
 1150 
 1151         if (codadebug & CODADBGMSK(CODA_LINK)) {
 1152                 myprintf(("nb_link:   vp fid: %s\n", coda_f2s(&cp->c_fid)));
 1153                 myprintf(("nb_link: tdvp fid: %s)\n",
 1154                     coda_f2s(&tdcp->c_fid)));
 1155         }
 1156         if (codadebug & CODADBGMSK(CODA_LINK)) {
 1157                 myprintf(("link:   vp fid: %s\n", coda_f2s(&cp->c_fid)));
 1158                 myprintf(("link: tdvp fid: %s\n", coda_f2s(&tdcp->c_fid)));
 1159         }
 1160 
 1161         /*
 1162          * Check for link to/from control object.
 1163          */
 1164         if (IS_CTL_NAME(tdvp, nm, len) || IS_CTL_VP(vp)) {
 1165                 MARK_INT_FAIL(CODA_LINK_STATS);
 1166                 return (EACCES);
 1167         }
 1168         error = venus_link(vtomi(vp), &cp->c_fid, &tdcp->c_fid, nm, len,
 1169             cred, td->td_proc);
 1170 
 1171         /*
 1172          * Invalidate the parent's attr cache, the modification time has
 1173          * changed.
 1174          */
 1175         VTOC(tdvp)->c_flags &= ~C_VATTR;
 1176         VTOC(vp)->c_flags &= ~C_VATTR;
 1177         CODADEBUG(CODA_LINK, myprintf(("in link result %d\n",error)););
 1178         return (error);
 1179 }
 1180 
 1181 int
 1182 coda_rename(struct vop_rename_args *ap)
 1183 {
 1184         /* true args */
 1185         struct vnode *fvp = ap->a_fvp;
 1186         struct vnode *tvp = ap->a_tvp;
 1187         struct vnode *odvp = ap->a_fdvp;
 1188         struct cnode *odcp = VTOC(odvp);
 1189         struct componentname  *fcnp = ap->a_fcnp;
 1190         struct vnode *ndvp = ap->a_tdvp;
 1191         struct cnode *ndcp = VTOC(ndvp);
 1192         struct componentname  *tcnp = ap->a_tcnp;
 1193         struct ucred *cred = fcnp->cn_cred;
 1194         struct thread *td = fcnp->cn_thread;
 1195         /* true args */
 1196         int error;
 1197         const char *fnm = fcnp->cn_nameptr;
 1198         int flen = fcnp->cn_namelen;
 1199         const char *tnm = tcnp->cn_nameptr;
 1200         int tlen = tcnp->cn_namelen;
 1201 
 1202         MARK_ENTRY(CODA_RENAME_STATS);
 1203 
 1204         /*
 1205          * Check for rename involving control object.
 1206          */
 1207         if (IS_CTL_NAME(odvp, fnm, flen) || IS_CTL_NAME(ndvp, tnm, tlen)) {
 1208                 MARK_INT_FAIL(CODA_RENAME_STATS);
 1209                 return (EACCES);
 1210         }
 1211 
 1212         /*
 1213          * Remove the entries for both source and target directories, which
 1214          * should catch references to the children.  Perhaps we could purge
 1215          * less?
 1216          */
 1217         cache_purge(odvp);
 1218         cache_purge(ndvp);
 1219 
 1220         /*
 1221          * Invalidate parent directories as modification times have changed.
 1222          * Invalidate access cache on renamed file as rights may have
 1223          * changed.
 1224          */
 1225         VTOC(odvp)->c_flags &= ~C_VATTR;
 1226         VTOC(ndvp)->c_flags &= ~C_VATTR;
 1227         VTOC(fvp)->c_flags &= ~C_ACCCACHE;
 1228         if (flen+1 > CODA_MAXNAMLEN) {
 1229                 MARK_INT_FAIL(CODA_RENAME_STATS);
 1230                 error = EINVAL;
 1231                 goto exit;
 1232         }
 1233         if (tlen+1 > CODA_MAXNAMLEN) {
 1234                 MARK_INT_FAIL(CODA_RENAME_STATS);
 1235                 error = EINVAL;
 1236                 goto exit;
 1237         }
 1238         error = venus_rename(vtomi(odvp), &odcp->c_fid, &ndcp->c_fid, fnm,
 1239             flen, tnm, tlen, cred, td->td_proc);
 1240 exit:
 1241         CODADEBUG(CODA_RENAME, myprintf(("in rename result %d\n",error)););
 1242 
 1243         /*
 1244          * Update namecache to reflect that the names of various objects may
 1245          * have changed (or gone away entirely).
 1246          */
 1247         cache_purge(fvp);
 1248         cache_purge(tvp);
 1249 
 1250         /*
 1251          * Release parents first, then children.
 1252          */
 1253         vrele(odvp);
 1254         if (tvp) {
 1255                 if (tvp == ndvp)
 1256                         vrele(ndvp);
 1257                 else
 1258                         vput(ndvp);
 1259                 vput(tvp);
 1260         } else
 1261                 vput(ndvp);
 1262         vrele(fvp);
 1263         return (error);
 1264 }
 1265 
 1266 int
 1267 coda_mkdir(struct vop_mkdir_args *ap)
 1268 {
 1269         /* true args */
 1270         struct vnode *dvp = ap->a_dvp;
 1271         struct cnode *dcp = VTOC(dvp);
 1272         struct componentname  *cnp = ap->a_cnp;
 1273         struct vattr *va = ap->a_vap;
 1274         struct vnode **vpp = ap->a_vpp;
 1275         struct ucred *cred = cnp->cn_cred;
 1276         struct thread *td = cnp->cn_thread;
 1277         /* locals */
 1278         int error;
 1279         const char *nm = cnp->cn_nameptr;
 1280         int len = cnp->cn_namelen;
 1281         struct cnode *cp;
 1282         struct CodaFid VFid;
 1283         struct vattr ova;
 1284 
 1285         MARK_ENTRY(CODA_MKDIR_STATS);
 1286 
 1287         /*
 1288          * Check for mkdir of target object.
 1289          */
 1290         if (IS_CTL_NAME(dvp, nm, len)) {
 1291                 *vpp = (struct vnode *)0;
 1292                 MARK_INT_FAIL(CODA_MKDIR_STATS);
 1293                 return (EACCES);
 1294         }
 1295         if (len+1 > CODA_MAXNAMLEN) {
 1296                 *vpp = (struct vnode *)0;
 1297                 MARK_INT_FAIL(CODA_MKDIR_STATS);
 1298                 return (EACCES);
 1299         }
 1300         error = venus_mkdir(vtomi(dvp), &dcp->c_fid, nm, len, va, cred,
 1301             td->td_proc, &VFid, &ova);
 1302         if (!error) {
 1303                 if (coda_find(&VFid) != NULL)
 1304                         panic("cnode existed for newly created directory!");
 1305                 cp =  make_coda_node(&VFid, dvp->v_mount, va->va_type);
 1306                 *vpp = CTOV(cp);
 1307 
 1308                 /*
 1309                  * Enter the new vnode in the Name Cache.
 1310                  */
 1311                 if (cnp->cn_flags & MAKEENTRY)
 1312                         cache_enter(dvp, *vpp, cnp);
 1313 
 1314                 /*
 1315                  * Update the attr cache and mark as valid.
 1316                  */
 1317                 if (coda_attr_cache) {
 1318                         VTOC(*vpp)->c_vattr = ova;
 1319                         VTOC(*vpp)->c_flags |= C_VATTR;
 1320                 }
 1321 
 1322                 /*
 1323                  * Invalidate the parent's attr cache, the modification time
 1324                  * has changed.
 1325                  */
 1326                 VTOC(dvp)->c_flags &= ~C_VATTR;
 1327                 vn_lock(*vpp, LK_EXCLUSIVE | LK_RETRY);
 1328                 CODADEBUG( CODA_MKDIR, myprintf(("mkdir: %s result %d\n",
 1329                     coda_f2s(&VFid), error)););
 1330         } else {
 1331                 *vpp = NULL;
 1332                 CODADEBUG(CODA_MKDIR, myprintf(("mkdir error %d\n",error)););
 1333         }
 1334         return (error);
 1335 }
 1336 
 1337 int
 1338 coda_rmdir(struct vop_rmdir_args *ap)
 1339 {
 1340         /* true args */
 1341         struct vnode *vp = ap->a_vp;
 1342         struct vnode *dvp = ap->a_dvp;
 1343         struct cnode *dcp = VTOC(dvp);
 1344         struct componentname  *cnp = ap->a_cnp;
 1345         struct ucred *cred = cnp->cn_cred;
 1346         struct thread *td = cnp->cn_thread;
 1347         /* true args */
 1348         int error;
 1349         const char *nm = cnp->cn_nameptr;
 1350         int len = cnp->cn_namelen;
 1351 #if 0
 1352         struct cnode *cp;
 1353 #endif
 1354 
 1355         MARK_ENTRY(CODA_RMDIR_STATS);
 1356 
 1357         /*
 1358          * Check for rmdir of control object.
 1359          */
 1360         if (IS_CTL_NAME(dvp, nm, len)) {
 1361                 MARK_INT_FAIL(CODA_RMDIR_STATS);
 1362                 return (ENOENT);
 1363         }
 1364 
 1365         /*
 1366          * Possibly somewhat conservative purging, perhaps we just need to
 1367          * purge vp?
 1368          */
 1369         cache_purge(dvp);
 1370         cache_purge(vp);
 1371 
 1372         /*
 1373          * Invalidate the parent's attr cache, the modification time has
 1374          * changed.
 1375          */
 1376         dcp->c_flags &= ~C_VATTR;
 1377         error = venus_rmdir(vtomi(dvp), &dcp->c_fid, nm, len, cred,
 1378             td->td_proc);
 1379         CODADEBUG(CODA_RMDIR, myprintf(("in rmdir result %d\n", error)););
 1380         return (error);
 1381 }
 1382 
 1383 int
 1384 coda_symlink(struct vop_symlink_args *ap)
 1385 {
 1386         /* true args */
 1387         struct vnode *tdvp = ap->a_dvp;
 1388         struct cnode *tdcp = VTOC(tdvp);
 1389         struct componentname *cnp = ap->a_cnp;
 1390         struct vattr *tva = ap->a_vap;
 1391         char *path = ap->a_target;
 1392         struct ucred *cred = cnp->cn_cred;
 1393         struct thread *td = cnp->cn_thread;
 1394         struct vnode **vpp = ap->a_vpp;
 1395         /* locals */
 1396         int error;
 1397 
 1398         /*-
 1399          * XXX I'm assuming the following things about coda_symlink's
 1400          * arguments:
 1401          *       t(foo) is the new name/parent/etc being created.
 1402          *       lname is the contents of the new symlink.
 1403          */
 1404         char *nm = cnp->cn_nameptr;
 1405         int len = cnp->cn_namelen;
 1406         int plen = strlen(path);
 1407 
 1408         /*
 1409          * Here's the strategy for the moment: perform the symlink, then do a
 1410          * lookup to grab the resulting vnode.  I know this requires two
 1411          * communications with Venus for a new sybolic link, but that's the
 1412          * way the ball bounces.  I don't yet want to change the way the Mach
 1413          * symlink works.  When Mach support is deprecated, we should change
 1414          * symlink so that the common case returns the resultant vnode in a
 1415          * vpp argument.
 1416          */
 1417         MARK_ENTRY(CODA_SYMLINK_STATS);
 1418 
 1419         /*
 1420          * Check for symlink of control object.
 1421          */
 1422         if (IS_CTL_NAME(tdvp, nm, len)) {
 1423                 MARK_INT_FAIL(CODA_SYMLINK_STATS);
 1424                 return (EACCES);
 1425         }
 1426         if (plen+1 > CODA_MAXPATHLEN) {
 1427                 MARK_INT_FAIL(CODA_SYMLINK_STATS);
 1428                 return (EINVAL);
 1429         }
 1430         if (len+1 > CODA_MAXNAMLEN) {
 1431                 MARK_INT_FAIL(CODA_SYMLINK_STATS);
 1432                 error = EINVAL;
 1433                 goto exit;
 1434         }
 1435         error = venus_symlink(vtomi(tdvp), &tdcp->c_fid, path, plen, nm, len,
 1436             tva, cred, td->td_proc);
 1437 
 1438         /*
 1439          * Invalidate the parent's attr cache, the modification time has
 1440          * changed.
 1441          */
 1442         tdcp->c_flags &= ~C_VATTR;
 1443         if (error == 0)
 1444                 error = VOP_LOOKUP(tdvp, vpp, cnp);
 1445 exit:
 1446         CODADEBUG(CODA_SYMLINK, myprintf(("in symlink result %d\n",error)););
 1447         return (error);
 1448 }
 1449 
 1450 /*
 1451  * Read directory entries.
 1452  *
 1453  * XXX: This forwards the operator straight to the cache vnode using
 1454  * VOP_READDIR(), rather than calling venus_readdir().  Why?
 1455  */
 1456 int
 1457 coda_readdir(struct vop_readdir_args *ap)
 1458 {
 1459         /* true args */
 1460         struct vnode *vp = ap->a_vp;
 1461         struct cnode *cp = VTOC(vp);
 1462         struct uio *uiop = ap->a_uio;
 1463         struct ucred *cred = ap->a_cred;
 1464         int *eofflag = ap->a_eofflag;
 1465         u_long **cookies = ap->a_cookies;
 1466         int *ncookies = ap->a_ncookies;
 1467         struct thread *td = ap->a_uio->uio_td;
 1468         /* upcall decl */
 1469         /* locals */
 1470         int error = 0;
 1471         int opened_internally = 0;
 1472 
 1473         MARK_ENTRY(CODA_READDIR_STATS);
 1474         CODADEBUG(CODA_READDIR, myprintf(("coda_readdir(%p, %zd, %lld, %d)\n",
 1475             (void *)uiop->uio_iov->iov_base, uiop->uio_resid,
 1476             (long long)uiop->uio_offset, uiop->uio_segflg)););
 1477 
 1478         /*
 1479          * Check for readdir of control object.
 1480          */
 1481         if (IS_CTL_VP(vp)) {
 1482                 MARK_INT_FAIL(CODA_READDIR_STATS);
 1483                 return (ENOENT);
 1484         }
 1485 
 1486         /*
 1487          * If directory is not already open do an "internal open" on it.
 1488          *
 1489          * XXX: Why would this happen?  For files, there's memory mapping,
 1490          * execution, and other kernel access paths such as ktrace.  For
 1491          * directories, it is less clear.
 1492          */
 1493         if (cp->c_ovp == NULL) {
 1494                 opened_internally = 1;
 1495                 MARK_INT_GEN(CODA_OPEN_STATS);
 1496                 error = VOP_OPEN(vp, FREAD, cred, td, NULL);
 1497                 printf("coda_readdir: Internally Opening %p\n", vp);
 1498                 if (error) {
 1499                         printf("coda_readdir: VOP_OPEN on container failed "
 1500                            "%d\n", error);
 1501                         return (error);
 1502                 }
 1503         }
 1504 
 1505         /*
 1506          * Have UFS handle the call.
 1507          */
 1508         CODADEBUG(CODA_READDIR, myprintf(("indirect readdir: fid = %s, "
 1509             "refcnt = %d\n", coda_f2s(&cp->c_fid), vp->v_usecount)););
 1510         vn_lock(cp->c_ovp, LK_SHARED | LK_RETRY);
 1511         error = VOP_READDIR(cp->c_ovp, uiop, cred, eofflag, ncookies,
 1512             cookies);
 1513         VOP_UNLOCK(cp->c_ovp, 0);
 1514         if (error)
 1515                 MARK_INT_FAIL(CODA_READDIR_STATS);
 1516         else
 1517                 MARK_INT_SAT(CODA_READDIR_STATS);
 1518 
 1519         /*
 1520          * Do an "internal close" if necessary.
 1521          */
 1522         if (opened_internally) {
 1523                 MARK_INT_GEN(CODA_CLOSE_STATS);
 1524                 (void)VOP_CLOSE(vp, FREAD, cred, td);
 1525         }
 1526         return (error);
 1527 }
 1528 
 1529 int
 1530 coda_reclaim(struct vop_reclaim_args *ap)
 1531 {
 1532         /* true args */
 1533         struct vnode *vp = ap->a_vp;
 1534         struct cnode *cp = VTOC(vp);
 1535         /* upcall decl */
 1536         /* locals */
 1537 
 1538         /*
 1539          * Forced unmount/flush will let vnodes with non-zero use be
 1540          * destroyed!
 1541          */
 1542         ENTRY;
 1543 
 1544         if (IS_UNMOUNTING(cp)) {
 1545 #ifdef  DEBUG
 1546                 if (VTOC(vp)->c_ovp) {
 1547                         if (IS_UNMOUNTING(cp))
 1548                                 printf("coda_reclaim: c_ovp not void: vp "
 1549                                     "%p, cp %p\n", vp, cp);
 1550                 }
 1551 #endif
 1552         }
 1553         cache_purge(vp);
 1554         coda_free(VTOC(vp));
 1555         vp->v_data = NULL;
 1556         vp->v_object = NULL;
 1557         return (0);
 1558 }
 1559 
 1560 int
 1561 coda_lock(struct vop_lock1_args *ap)
 1562 {
 1563         /* true args */
 1564         struct vnode *vp = ap->a_vp;
 1565         struct cnode *cp = VTOC(vp);
 1566         /* upcall decl */
 1567         /* locals */
 1568 
 1569         ENTRY;
 1570         if ((ap->a_flags & LK_INTERLOCK) == 0) {
 1571                 VI_LOCK(vp);
 1572                 ap->a_flags |= LK_INTERLOCK;
 1573         }
 1574         if (coda_lockdebug)
 1575                 myprintf(("Attempting lock on %s\n", coda_f2s(&cp->c_fid)));
 1576         return (vop_stdlock(ap));
 1577 }
 1578 
 1579 int
 1580 coda_unlock(struct vop_unlock_args *ap)
 1581 {
 1582         /* true args */
 1583         struct vnode *vp = ap->a_vp;
 1584         struct cnode *cp = VTOC(vp);
 1585         /* upcall decl */
 1586         /* locals */
 1587 
 1588         ENTRY;
 1589         if (coda_lockdebug)
 1590                 myprintf(("Attempting unlock on %s\n",
 1591                     coda_f2s(&cp->c_fid)));
 1592         return (vop_stdunlock(ap));
 1593 }
 1594 
 1595 int
 1596 coda_islocked(struct vop_islocked_args *ap)
 1597 {
 1598         /* true args */
 1599 
 1600         ENTRY;
 1601         return (vop_stdislocked(ap));
 1602 }
 1603 
 1604 static void
 1605 coda_print_vattr(struct vattr *attr)
 1606 {
 1607         char *typestr;
 1608 
 1609         switch (attr->va_type) {
 1610         case VNON:
 1611                 typestr = "VNON";
 1612                 break;
 1613 
 1614         case VREG:
 1615                 typestr = "VREG";
 1616                 break;
 1617 
 1618         case VDIR:
 1619                 typestr = "VDIR";
 1620                 break;
 1621 
 1622         case VBLK:
 1623                 typestr = "VBLK";
 1624                 break;
 1625 
 1626         case VCHR:
 1627                 typestr = "VCHR";
 1628                 break;
 1629 
 1630         case VLNK:
 1631                 typestr = "VLNK";
 1632                 break;
 1633 
 1634         case VSOCK:
 1635                 typestr = "VSCK";
 1636                 break;
 1637 
 1638         case VFIFO:
 1639                 typestr = "VFFO";
 1640                 break;
 1641 
 1642         case VBAD:
 1643                 typestr = "VBAD";
 1644                 break;
 1645 
 1646         default:
 1647                 typestr = "????";
 1648                 break;
 1649         }
 1650         myprintf(("attr: type %s mode %d uid %d gid %d fsid %d rdev %d\n",
 1651             typestr, (int)attr->va_mode, (int)attr->va_uid,
 1652             (int)attr->va_gid, (int)attr->va_fsid, (int)attr->va_rdev));
 1653         myprintf(("      fileid %d nlink %d size %d blocksize %d bytes %d\n",
 1654             (int)attr->va_fileid, (int)attr->va_nlink, (int)attr->va_size,
 1655             (int)attr->va_blocksize,(int)attr->va_bytes));
 1656         myprintf(("      gen %ld flags %ld vaflags %d\n", attr->va_gen,
 1657             attr->va_flags, attr->va_vaflags));
 1658         myprintf(("      atime sec %d nsec %d\n", (int)attr->va_atime.tv_sec,
 1659             (int)attr->va_atime.tv_nsec));
 1660         myprintf(("      mtime sec %d nsec %d\n", (int)attr->va_mtime.tv_sec,
 1661             (int)attr->va_mtime.tv_nsec));
 1662         myprintf(("      ctime sec %d nsec %d\n", (int)attr->va_ctime.tv_sec,
 1663             (int)attr->va_ctime.tv_nsec));
 1664 }
 1665 
 1666 /*
 1667  * How to print a ucred.
 1668  */
 1669 void
 1670 coda_print_cred(struct ucred *cred)
 1671 {
 1672         int i;
 1673 
 1674         myprintf(("ref %d\tuid %d\n",cred->cr_ref,cred->cr_uid));
 1675         for (i=0; i < cred->cr_ngroups; i++)
 1676                 myprintf(("\tgroup %d: (%d)\n",i,cred->cr_groups[i]));
 1677         myprintf(("\n"));
 1678 }
 1679 
 1680 /*
 1681  * Return a vnode for the given fid.  If no cnode exists for this fid create
 1682  * one and put it in a table hashed by coda_f2i().  If the cnode for this fid
 1683  * is already in the table return it (ref count is incremented by coda_find.
 1684  * The cnode will be flushed from the table when coda_inactive calls
 1685  * coda_unsave.
 1686  */
 1687 struct cnode *
 1688 make_coda_node(struct CodaFid *fid, struct mount *vfsp, short type)
 1689 {
 1690         struct cnode *cp;
 1691         struct vnode *vp;
 1692         int err;
 1693 
 1694         /*
 1695          * XXXRW: This really needs a moderate amount of reworking.  We need
 1696          * to properly tolerate failures of getnewvnode() and insmntque(),
 1697          * and callers need to be able to accept an error back from
 1698          * make_coda_node.  There may also be more general issues in how we
 1699          * handle forced unmount.  Finally, if/when Coda loses its dependency
 1700          * on Giant, the ordering of this needs rethinking.
 1701          */
 1702         cp = coda_find(fid);
 1703         if (cp != NULL) {
 1704                 vref(CTOV(cp));
 1705                 return (cp);
 1706         }
 1707         cp = coda_alloc();
 1708         cp->c_fid = *fid;
 1709         err = getnewvnode("coda", vfsp, &coda_vnodeops, &vp);
 1710         if (err)
 1711                 panic("coda: getnewvnode returned error %d\n", err);
 1712         vp->v_data = cp;
 1713         vp->v_type = type;
 1714         cp->c_vnode = vp;
 1715         coda_save(cp);
 1716         err = insmntque(vp, vfsp);
 1717         if (err != 0)
 1718                 printf("coda: insmntque failed: error %d", err);
 1719         return (cp);
 1720 }
 1721 
 1722 int
 1723 coda_pathconf(struct vop_pathconf_args *ap)
 1724 {
 1725 
 1726         switch (ap->a_name) {
 1727         case _PC_NAME_MAX:
 1728                 *ap->a_retval = CODA_MAXNAMLEN;
 1729                 return (0);
 1730 
 1731         case _PC_PATH_MAX:
 1732                 *ap->a_retval = CODA_MAXPATHLEN;
 1733                 return (0);
 1734 
 1735         default:
 1736                 return (vop_stdpathconf(ap));
 1737         }
 1738 }

Cache object: 26044acd6069293124bdc745b99b5651


[ 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.