sys/fs/coda/coda_vnops.c

   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, td);
 241         error = VOP_OPEN(vp, flag, cred, td, NULL);
 242         if (error) {
 243                 VOP_UNLOCK(vp, 0, td);
 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, td);
 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, td);
 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, %d, %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, td);
 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, td) == 0)
 386                                 vnode_pager_setsize(vp, attr.va_size);
 387                 }
 388         }
 389         VOP_UNLOCK(cfvp, 0, td);
 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                 NDFREE(&ndp, 0);
 476                 return (EINVAL);
 477         }
 478         error = venus_ioctl(vtomi(tvp), &((VTOC(tvp))->c_fid), com, flag,
 479             data, cred, td->td_proc);
 480         if (error)
 481                 MARK_INT_FAIL(CODA_IOCTL_STATS);
 482         else
 483                 CODADEBUG(CODA_IOCTL, myprintf(("Ioctl returns %d \n",
 484                     error)););
 485         vrele(tvp);
 486         NDFREE(&ndp, NDF_ONLY_PNBUF);
 487         return (error);
 488 }
 489
 490 /*
 491  * To reduce the cost of a user-level venus;we cache attributes in the
 492  * kernel.  Each cnode has storage allocated for an attribute.  If c_vattr is
 493  * valid, return a reference to it.  Otherwise, get the attributes from venus
 494  * and store them in the cnode.  There is some question if this method is a
 495  * security leak.  But I think that in order to make this call, the user must
 496  * have done a lookup and opened the file, and therefore should already have
 497  * access.
 498  */
 499 int
 500 coda_getattr(struct vop_getattr_args *ap)
 501 {
 502         /* true args */
 503         struct vnode *vp = ap->a_vp;
 504         struct cnode *cp = VTOC(vp);
 505         struct vattr *vap = ap->a_vap;
 506         struct ucred *cred = ap->a_cred;
 507         struct thread *td = ap->a_td;
 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, td->td_proc, 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         struct thread *td = ap->a_td;
 572         /* locals */
 573         struct vnode *convp;
 574         int error, size;
 575
 576         MARK_ENTRY(CODA_SETATTR_STATS);
 577
 578         /*
 579          * Check for setattr of control object.
 580          */
 581         if (IS_CTL_VP(vp)) {
 582                 MARK_INT_FAIL(CODA_SETATTR_STATS);
 583                 return (ENOENT);
 584         }
 585         if (codadebug & CODADBGMSK(CODA_SETATTR))
 586                 coda_print_vattr(vap);
 587         error = venus_setattr(vtomi(vp), &cp->c_fid, vap, cred, td->td_proc);
 588         if (!error)
 589                 cp->c_flags &= ~(C_VATTR | C_ACCCACHE);
 590
 591         /*
 592          * XXX: Since we now share vm objects between layers, this is
 593          * probably unnecessary.
 594          *
 595          * XXX: Shouldn't we only be doing this "set" if C_VATTR remains
 596          * valid after venus_setattr()?
 597          */
 598         size = vap->va_size;
 599         convp = cp->c_ovp;
 600         if (size != VNOVAL && convp != NULL)
 601                 vnode_pager_setsize(convp, size);
 602         CODADEBUG(CODA_SETATTR, myprintf(("setattr %d\n", error)););
 603         return (error);
 604 }
 605
 606 int
 607 coda_access(struct vop_access_args *ap)
 608 {
 609         /* true args */
 610         struct vnode *vp = ap->a_vp;
 611         struct cnode *cp = VTOC(vp);
 612         int mode = ap->a_mode;
 613         struct ucred *cred = ap->a_cred;
 614         struct thread *td = ap->a_td;
 615         /* locals */
 616         int error;
 617
 618         MARK_ENTRY(CODA_ACCESS_STATS);
 619
 620         /*
 621          * Check for access of control object.  Only read access is allowed
 622          * on it.
 623          */
 624         if (IS_CTL_VP(vp)) {
 625                 /*
 626                  * Bogus hack - all will be marked as successes.
 627                  */
 628                 MARK_INT_SAT(CODA_ACCESS_STATS);
 629                 return (((mode & VREAD) && !(mode & (VWRITE | VEXEC)))
 630                     ? 0 : EACCES);
 631         }
 632
 633         /*
 634          * We maintain a one-entry LRU positive access cache with each cnode.
 635          * In principle we could also track negative results, and for more
 636          * than one uid, but we don't yet.  Venus is responsible for
 637          * invalidating this cache as required.
 638          */
 639         if (coda_access_cache && VALID_ACCCACHE(cp) &&
 640             (cred->cr_uid == cp->c_cached_uid) &&
 641             (mode & cp->c_cached_mode) == mode) {
 642                 MARK_INT_SAT(CODA_ACCESS_STATS);
 643                 return (0);
 644         }
 645         error = venus_access(vtomi(vp), &cp->c_fid, mode, cred, td->td_proc);
 646         if (error == 0 && coda_access_cache) {
 647                 /*-
 648                  * When we have a new successful request, we consider three
 649                  * cases:
 650                  *
 651                  * - No initialized access cache, in which case cache the
 652                  *   result.
 653                  * - Cached result for a different user, in which case we
 654                  *   replace the entry.
 655                  * - Cached result for the same user, in which case we add
 656                  *   any newly granted rights to the cached mode.
 657                  *
 658                  * XXXRW: If we ever move to something more interesting than
 659                  * uid-based token lookup, we'll need to change this.
 660                  */
 661                 cp->c_flags |= C_ACCCACHE;
 662                 if (cp->c_cached_uid != cred->cr_uid) {
 663                         cp->c_cached_mode = mode;
 664                         cp->c_cached_uid = cred->cr_uid;
 665                 } else
 666                         cp->c_cached_mode |= mode;
 667         }
 668         return (error);
 669 }
 670
 671 int
 672 coda_readlink(struct vop_readlink_args *ap)
 673 {
 674         /* true args */
 675         struct vnode *vp = ap->a_vp;
 676         struct cnode *cp = VTOC(vp);
 677         struct uio *uiop = ap->a_uio;
 678         struct ucred *cred = ap->a_cred;
 679         struct thread *td = ap->a_uio->uio_td;
 680         /* locals */
 681         int error;
 682         char *str;
 683         int len;
 684
 685         MARK_ENTRY(CODA_READLINK_STATS);
 686
 687         /*
 688          * Check for readlink of control object.
 689          */
 690         if (IS_CTL_VP(vp)) {
 691                 MARK_INT_FAIL(CODA_READLINK_STATS);
 692                 return (ENOENT);
 693         }
 694         if ((coda_symlink_cache) && (VALID_SYMLINK(cp))) {
 695                 /*
 696                  * Symlink was cached.
 697                  */
 698                 uiop->uio_rw = UIO_READ;
 699                 error = uiomove(cp->c_symlink, (int)cp->c_symlen, uiop);
 700                 if (error)
 701                         MARK_INT_FAIL(CODA_READLINK_STATS);
 702                 else
 703                         MARK_INT_SAT(CODA_READLINK_STATS);
 704                 return (error);
 705         }
 706         error = venus_readlink(vtomi(vp), &cp->c_fid, cred, td != NULL ?
 707             td->td_proc : NULL, &str, &len);
 708         if (!error) {
 709                 uiop->uio_rw = UIO_READ;
 710                 error = uiomove(str, len, uiop);
 711                 if (coda_symlink_cache) {
 712                         cp->c_symlink = str;
 713                         cp->c_symlen = len;
 714                         cp->c_flags |= C_SYMLINK;
 715                 } else
 716                         CODA_FREE(str, len);
 717         }
 718         CODADEBUG(CODA_READLINK, myprintf(("in readlink result %d\n",
 719             error)););
 720         return (error);
 721 }
 722
 723 int
 724 coda_fsync(struct vop_fsync_args *ap)
 725 {
 726         /* true args */
 727         struct vnode *vp = ap->a_vp;
 728         struct cnode *cp = VTOC(vp);
 729         struct thread *td = ap->a_td;
 730         /* locals */
 731         struct vnode *convp = cp->c_ovp;
 732         int error;
 733
 734         MARK_ENTRY(CODA_FSYNC_STATS);
 735
 736         /*
 737          * Check for fsync on an unmounting object.
 738          *
 739          * XXX: Is this comment true on FreeBSD?  It seems likely, since
 740          * unmounting is fairly non-atomic.
 741          *
 742          * The NetBSD kernel, in it's infinite wisdom, can try to fsync after
 743          * an unmount has been initiated.  This is a Bad Thing, which we have
 744          * to avoid.  Not a legitimate failure for stats.
 745          */
 746         if (IS_UNMOUNTING(cp))
 747                 return (ENODEV);
 748
 749         /*
 750          * Check for fsync of control object.
 751          */
 752         if (IS_CTL_VP(vp)) {
 753                 MARK_INT_SAT(CODA_FSYNC_STATS);
 754                 return (0);
 755         }
 756         if (convp != NULL) {
 757                 vn_lock(convp, LK_EXCLUSIVE | LK_RETRY, td);
 758                 VOP_FSYNC(convp, MNT_WAIT, td);
 759                 VOP_UNLOCK(convp, 0, td);
 760         }
 761
 762         /*
 763          * We see fsyncs with usecount == 1 then usecount == 0.  For now we
 764          * ignore them.
 765          */
 766 #if 0
 767         VI_LOCK(vp);
 768         if (!vp->v_usecount) {
 769                 printf("coda_fsync on vnode %p with %d usecount.  "
 770                     "c_flags = %x (%x)\n", vp, vp->v_usecount, cp->c_flags,
 771                     cp->c_flags&C_PURGING);
 772         }
 773         VI_UNLOCK(vp);
 774 #endif
 775
 776         /*
 777          * We can expect fsync on any vnode at all if venus is purging it.
 778          * Venus can't very well answer the fsync request, now can it?
 779          * Hopefully, it won't have to, because hopefully, venus preserves
 780          * the (possibly untrue) invariant that it never purges an open
 781          * vnode.  Hopefully.
 782          */
 783         if (cp->c_flags & C_PURGING)
 784                 return (0);
 785
 786         /* XXX: needs research */
 787         return (0);
 788         error = venus_fsync(vtomi(vp), &cp->c_fid, td->td_proc);
 789         CODADEBUG(CODA_FSYNC, myprintf(("in fsync result %d\n", error)););
 790         return (error);
 791 }
 792
 793 int
 794 coda_inactive(struct vop_inactive_args *ap)
 795 {
 796         /*
 797          * XXX - at the moment, inactive doesn't look at cred, and doesn't
 798          * have a proc pointer.  Oops.
 799          */
 800         /* true args */
 801         struct vnode *vp = ap->a_vp;
 802         struct cnode *cp = VTOC(vp);
 803         struct ucred *cred __attribute__((unused)) = NULL;
 804         struct thread *td __attribute__((unused)) = curthread;
 805         /* upcall decl */
 806         /* locals */
 807
 808         /*
 809          * We don't need to send inactive to venus - DCS.
 810          */
 811         MARK_ENTRY(CODA_INACTIVE_STATS);
 812         CODADEBUG(CODA_INACTIVE, myprintf(("in inactive, %s, vfsp %p\n",
 813             coda_f2s(&cp->c_fid), vp->v_mount)););
 814         vp->v_object = NULL;
 815
 816         /*
 817          * If an array has been allocated to hold the symlink, deallocate it.
 818          */
 819         if ((coda_symlink_cache) && (VALID_SYMLINK(cp))) {
 820                 if (cp->c_symlink == NULL)
 821                         panic("coda_inactive: null symlink pointer in cnode");
 822                 CODA_FREE(cp->c_symlink, cp->c_symlen);
 823                 cp->c_flags &= ~C_SYMLINK;
 824                 cp->c_symlen = 0;
 825         }
 826
 827         /*
 828          * Remove it from the table so it can't be found.
 829          */
 830         coda_unsave(cp);
 831         if ((struct coda_mntinfo *)(vp->v_mount->mnt_data) == NULL) {
 832                 myprintf(("Help! vfsp->vfs_data was NULL, but vnode %p "
 833                     "wasn't dying\n", vp));
 834                 panic("badness in coda_inactive\n");
 835         }
 836         if (IS_UNMOUNTING(cp)) {
 837 #ifdef  DEBUG
 838                 printf("coda_inactive: IS_UNMOUNTING use %d: vp %p, cp %p\n",
 839                     vrefcnt(vp), vp, cp);
 840                 if (cp->c_ovp != NULL)
 841                         printf("coda_inactive: cp->ovp != NULL use %d: vp "
 842                             "%p, cp %p\n", vrefcnt(vp), vp, cp);
 843 #endif
 844         } else
 845                 vgone(vp);
 846         MARK_INT_SAT(CODA_INACTIVE_STATS);
 847         return (0);
 848 }
 849
 850 /*
 851  * Remote filesystem operations having to do with directory manipulation.
 852  */
 853
 854 /*
 855  * In FreeBSD, lookup returns the vnode locked.
 856  */
 857 int
 858 coda_lookup(struct vop_cachedlookup_args *ap)
 859 {
 860         /* true args */
 861         struct vnode *dvp = ap->a_dvp;
 862         struct cnode *dcp = VTOC(dvp);
 863         struct vnode **vpp = ap->a_vpp;
 864         /*
 865          * It looks as though ap->a_cnp->ni_cnd->cn_nameptr holds the rest of
 866          * the string to xlate, and that we must try to get at least
 867          * ap->a_cnp->ni_cnd->cn_namelen of those characters to macth.  I
 868          * could be wrong.
 869          */
 870         struct componentname  *cnp = ap->a_cnp;
 871         struct ucred *cred = cnp->cn_cred;
 872         struct thread *td = cnp->cn_thread;
 873         /* locals */
 874         struct cnode *cp;
 875         const char *nm = cnp->cn_nameptr;
 876         int len = cnp->cn_namelen;
 877         CodaFid VFid;
 878         int vtype;
 879         int error = 0;
 880
 881         MARK_ENTRY(CODA_LOOKUP_STATS);
 882         CODADEBUG(CODA_LOOKUP, myprintf(("lookup: %s in %s\n", nm,
 883             coda_f2s(&dcp->c_fid))););
 884
 885         /*
 886          * Check for lookup of control object.
 887          */
 888         if (IS_CTL_NAME(dvp, nm, len)) {
 889                 *vpp = coda_ctlvp;
 890                 vref(*vpp);
 891                 MARK_INT_SAT(CODA_LOOKUP_STATS);
 892                 goto exit;
 893         }
 894         if (len+1 > CODA_MAXNAMLEN) {
 895                 MARK_INT_FAIL(CODA_LOOKUP_STATS);
 896                 CODADEBUG(CODA_LOOKUP, myprintf(("name too long: lookup, "
 897                     "%s (%s)\n", coda_f2s(&dcp->c_fid), nm)););
 898                 *vpp = NULL;
 899                 error = EINVAL;
 900                 goto exit;
 901         }
 902
 903         error = venus_lookup(vtomi(dvp), &dcp->c_fid, nm, len, cred,
 904             td->td_proc, &VFid, &vtype);
 905         if (error) {
 906                 MARK_INT_FAIL(CODA_LOOKUP_STATS);
 907                 CODADEBUG(CODA_LOOKUP, myprintf(("lookup error on %s "
 908                     "(%s)%d\n", coda_f2s(&dcp->c_fid), nm, error)););
 909                 *vpp = NULL;
 910         } else {
 911                 MARK_INT_SAT(CODA_LOOKUP_STATS);
 912                 CODADEBUG(CODA_LOOKUP, myprintf(("lookup: %s type %o "
 913                     "result %d\n", coda_f2s(&VFid), vtype, error)););
 914                 cp = make_coda_node(&VFid, dvp->v_mount, vtype);
 915                 *vpp = CTOV(cp);
 916
 917                 /*
 918                  * Enter the new vnode in the namecache only if the top bit
 919                  * isn't set.
 920                  *
 921                  * And don't enter a new vnode for an invalid one!
 922                  */
 923                 if (!(vtype & CODA_NOCACHE) && (cnp->cn_flags & MAKEENTRY))
 924                         cache_enter(dvp, *vpp, cnp);
 925         }
 926 exit:
 927         /*
 928          * If we are creating, and this was the last name to be looked up,
 929          * and the error was ENOENT, then there really shouldn't be an error
 930          * and we can make the leaf NULL and return success.  Since this is
 931          * supposed to work under Mach as well as FreeBSD, we're leaving this
 932          * fn wrapped.  We also must tell lookup/namei that we need to save
 933          * the last component of the name.  (Create will have to free the
 934          * name buffer later...lucky us...).
 935          */
 936         if (((cnp->cn_nameiop == CREATE) || (cnp->cn_nameiop == RENAME))
 937             && (cnp->cn_flags & ISLASTCN) && (error == ENOENT)) {
 938                 error = EJUSTRETURN;
 939                 cnp->cn_flags |= SAVENAME;
 940                 *ap->a_vpp = NULL;
 941         }
 942
 943         /*
 944          * If we are removing, and we are at the last element, and we found
 945          * it, then we need to keep the name around so that the removal will
 946          * go ahead as planned.  Unfortunately, this will probably also lock
 947          * the to-be-removed vnode, which may or may not be a good idea.
 948          * I'll have to look at the bits of coda_remove to make sure.  We'll
 949          * only save the name if we did in fact find the name, otherwise
 950          * coda_remove won't have a chance to free the pathname.
 951          */
 952         if ((cnp->cn_nameiop == DELETE) && (cnp->cn_flags & ISLASTCN)
 953             && !error)
 954                 cnp->cn_flags |= SAVENAME;
 955
 956         /*
 957          * If the lookup went well, we need to (potentially?) unlock the
 958          * parent, and lock the child.  We are only responsible for checking
 959          * to see if the parent is supposed to be unlocked before we return.
 960          * We must always lock the child (provided there is one, and (the
 961          * parent isn't locked or it isn't the same as the parent.)  Simple,
 962          * huh?  We can never leave the parent locked unless we are ISLASTCN.
 963          */
 964         if (!error || (error == EJUSTRETURN)) {
 965                 if (cnp->cn_flags & ISDOTDOT) {
 966                         VOP_UNLOCK(dvp, 0, td);
 967                         /*
 968                          * The parent is unlocked.  As long as there is a
 969                          * child, lock it without bothering to check anything
 970                          * else.
 971                          */
 972                         if (*ap->a_vpp)
 973                                 vn_lock(*ap->a_vpp, LK_EXCLUSIVE | LK_RETRY,
 974                                     td);
 975                         vn_lock(dvp, LK_RETRY|LK_EXCLUSIVE, td);
 976                 } else {
 977                         /*
 978                          * The parent is locked, and may be the same as the
 979                          * child.  If different, go ahead and lock it.
 980                          */
 981                         if (*ap->a_vpp && (*ap->a_vpp != dvp))
 982                                 vn_lock(*ap->a_vpp, LK_EXCLUSIVE | LK_RETRY,
 983                                     td);
 984                 }
 985         } else {
 986                 /*
 987                  * If the lookup failed, we need to ensure that the leaf is
 988                  * NULL.
 989                  *
 990                  * Don't change any locking?
 991                  */
 992                 *ap->a_vpp = NULL;
 993         }
 994         return (error);
 995 }
 996
 997 /*ARGSUSED*/
 998 int
 999 coda_create(struct vop_create_args *ap)
1000 {
1001         /* true args */
1002         struct vnode *dvp = ap->a_dvp;
1003         struct cnode *dcp = VTOC(dvp);
1004         struct vattr *va = ap->a_vap;
1005         int exclusive = 1;
1006         int mode = ap->a_vap->va_mode;
1007         struct vnode **vpp = ap->a_vpp;
1008         struct componentname  *cnp = ap->a_cnp;
1009         struct ucred *cred = cnp->cn_cred;
1010         struct thread *td = cnp->cn_thread;
1011         /* locals */
1012         int error;
1013         struct cnode *cp;
1014         const char *nm = cnp->cn_nameptr;
1015         int len = cnp->cn_namelen;
1016         CodaFid VFid;
1017         struct vattr attr;
1018
1019         MARK_ENTRY(CODA_CREATE_STATS);
1020
1021         /*
1022          * All creates are exclusive XXX.
1023          *
1024          * I'm assuming the 'mode' argument is the file mode bits XXX.
1025          *
1026          * Check for create of control object.
1027          */
1028         if (IS_CTL_NAME(dvp, nm, len)) {
1029                 *vpp = (struct vnode *)0;
1030                 MARK_INT_FAIL(CODA_CREATE_STATS);
1031                 return (EACCES);
1032         }
1033         error = venus_create(vtomi(dvp), &dcp->c_fid, nm, len, exclusive,
1034             mode, va, cred, td->td_proc, &VFid, &attr);
1035         if (!error) {
1036                 /*
1037                  * If this is an exclusive create, panic if the file already
1038                  * exists.
1039                  *
1040                  * Venus should have detected the file and reported EEXIST.
1041                  */
1042                 if ((exclusive == 1) && (coda_find(&VFid) != NULL))
1043                         panic("cnode existed for newly created file!");
1044                 cp = make_coda_node(&VFid, dvp->v_mount, attr.va_type);
1045                 *vpp = CTOV(cp);
1046
1047                 /*
1048                  * Update va to reflect the new attributes.
1049                  */
1050                 (*va) = attr;
1051
1052                 /*
1053                  * Update the attribute cache and mark it as valid.
1054                  */
1055                 if (coda_attr_cache) {
1056                         VTOC(*vpp)->c_vattr = attr;
1057                         VTOC(*vpp)->c_flags |= C_VATTR;
1058                 }
1059
1060                 /*
1061                  * Invalidate the parent's attr cache, the modification time
1062                  * has changed.
1063                  */
1064                 VTOC(dvp)->c_flags &= ~C_VATTR;
1065                 cache_enter(dvp, *vpp, cnp);
1066                 CODADEBUG(CODA_CREATE, myprintf(("create: %s, result %d\n",
1067                     coda_f2s(&VFid), error)););
1068         } else {
1069                 *vpp = (struct vnode *)0;
1070                 CODADEBUG(CODA_CREATE, myprintf(("create error %d\n",
1071                     error)););
1072         }
1073         if (!error) {
1074                 if (cnp->cn_flags & MAKEENTRY)
1075                         cache_enter(dvp, *vpp, cnp);
1076                 if (cnp->cn_flags & LOCKLEAF)
1077                         vn_lock(*ap->a_vpp, LK_EXCLUSIVE | LK_RETRY, td);
1078         } else if (error == ENOENT) {
1079                 /*
1080                  * XXXRW: We only enter a negative entry if ENOENT is
1081                  * returned, not other errors.  But will Venus invalidate dvp
1082                  * properly in all cases when new files appear via the
1083                  * network rather than a local operation?
1084                  */
1085                 if (cnp->cn_flags & MAKEENTRY)
1086                         cache_enter(dvp, NULL, cnp);
1087         }
1088         return (error);
1089 }
1090
1091 int
1092 coda_remove(struct vop_remove_args *ap)
1093 {
1094         /* true args */
1095         struct vnode *vp = ap->a_vp;
1096         struct vnode *dvp = ap->a_dvp;
1097         struct cnode *cp = VTOC(dvp);
1098         struct componentname  *cnp = ap->a_cnp;
1099         struct ucred *cred = cnp->cn_cred;
1100         struct thread *td = cnp->cn_thread;
1101         /* locals */
1102         int error;
1103         const char *nm = cnp->cn_nameptr;
1104         int len = cnp->cn_namelen;
1105 #if 0
1106         struct cnode *tp;
1107 #endif
1108
1109         MARK_ENTRY(CODA_REMOVE_STATS);
1110         CODADEBUG(CODA_REMOVE, myprintf(("remove: %s in %s\n", nm,
1111             coda_f2s(&cp->c_fid))););
1112
1113         /*
1114          * Check for remove of control object.
1115          */
1116         if (IS_CTL_NAME(dvp, nm, len)) {
1117                 MARK_INT_FAIL(CODA_REMOVE_STATS);
1118                 return (ENOENT);
1119         }
1120
1121         /*
1122          * Invalidate the parent's attr cache, the modification time has
1123          * changed.  We don't yet know if the last reference to the file is
1124          * being removed, but we do know the reference count on the child has
1125          * changed, so invalidate its attr cache also.
1126          */
1127         VTOC(dvp)->c_flags &= ~C_VATTR;
1128         VTOC(vp)->c_flags &= ~(C_VATTR | C_ACCCACHE);
1129         error = venus_remove(vtomi(dvp), &cp->c_fid, nm, len, cred,
1130             td->td_proc);
1131         cache_purge(vp);
1132         CODADEBUG(CODA_REMOVE, myprintf(("in remove result %d\n",error)););
1133         return (error);
1134 }
1135
1136 int
1137 coda_link(struct vop_link_args *ap)
1138 {
1139         /* true args */
1140         struct vnode *vp = ap->a_vp;
1141         struct cnode *cp = VTOC(vp);
1142         struct vnode *tdvp = ap->a_tdvp;
1143         struct cnode *tdcp = VTOC(tdvp);
1144         struct componentname *cnp = ap->a_cnp;
1145         struct ucred *cred = cnp->cn_cred;
1146         struct thread *td = cnp->cn_thread;
1147         /* locals */
1148         int error;
1149         const char *nm = cnp->cn_nameptr;
1150         int len = cnp->cn_namelen;
1151
1152         MARK_ENTRY(CODA_LINK_STATS);
1153
1154         if (codadebug & CODADBGMSK(CODA_LINK)) {
1155                 myprintf(("nb_link:   vp fid: %s\n", coda_f2s(&cp->c_fid)));
1156                 myprintf(("nb_link: tdvp fid: %s)\n",
1157                     coda_f2s(&tdcp->c_fid)));
1158         }
1159         if (codadebug & CODADBGMSK(CODA_LINK)) {
1160                 myprintf(("link:   vp fid: %s\n", coda_f2s(&cp->c_fid)));
1161                 myprintf(("link: tdvp fid: %s\n", coda_f2s(&tdcp->c_fid)));
1162         }
1163
1164         /*
1165          * Check for link to/from control object.
1166          */
1167         if (IS_CTL_NAME(tdvp, nm, len) || IS_CTL_VP(vp)) {
1168                 MARK_INT_FAIL(CODA_LINK_STATS);
1169                 return (EACCES);
1170         }
1171         error = venus_link(vtomi(vp), &cp->c_fid, &tdcp->c_fid, nm, len,
1172             cred, td->td_proc);
1173
1174         /*
1175          * Invalidate the parent's attr cache, the modification time has
1176          * changed.
1177          */
1178         VTOC(tdvp)->c_flags &= ~C_VATTR;
1179         VTOC(vp)->c_flags &= ~C_VATTR;
1180         CODADEBUG(CODA_LINK, myprintf(("in link result %d\n",error)););
1181         return (error);
1182 }
1183
1184 int
1185 coda_rename(struct vop_rename_args *ap)
1186 {
1187         /* true args */
1188         struct vnode *fvp = ap->a_fvp;
1189         struct vnode *tvp = ap->a_tvp;
1190         struct vnode *odvp = ap->a_fdvp;
1191         struct cnode *odcp = VTOC(odvp);
1192         struct componentname  *fcnp = ap->a_fcnp;
1193         struct vnode *ndvp = ap->a_tdvp;
1194         struct cnode *ndcp = VTOC(ndvp);
1195         struct componentname  *tcnp = ap->a_tcnp;
1196         struct ucred *cred = fcnp->cn_cred;
1197         struct thread *td = fcnp->cn_thread;
1198         /* true args */
1199         int error;
1200         const char *fnm = fcnp->cn_nameptr;
1201         int flen = fcnp->cn_namelen;
1202         const char *tnm = tcnp->cn_nameptr;
1203         int tlen = tcnp->cn_namelen;
1204
1205         MARK_ENTRY(CODA_RENAME_STATS);
1206
1207         /*
1208          * Check for rename involving control object.
1209          */
1210         if (IS_CTL_NAME(odvp, fnm, flen) || IS_CTL_NAME(ndvp, tnm, tlen)) {
1211                 MARK_INT_FAIL(CODA_RENAME_STATS);
1212                 return (EACCES);
1213         }
1214
1215         /*
1216          * Remove the entries for both source and target directories, which
1217          * should catch references to the children.  Perhaps we could purge
1218          * less?
1219          */
1220         cache_purge(odvp);
1221         cache_purge(ndvp);
1222
1223         /*
1224          * Invalidate parent directories as modification times have changed.
1225          * Invalidate access cache on renamed file as rights may have
1226          * changed.
1227          */
1228         VTOC(odvp)->c_flags &= ~C_VATTR;
1229         VTOC(ndvp)->c_flags &= ~C_VATTR;
1230         VTOC(fvp)->c_flags &= ~C_ACCCACHE;
1231         if (flen+1 > CODA_MAXNAMLEN) {
1232                 MARK_INT_FAIL(CODA_RENAME_STATS);
1233                 error = EINVAL;
1234                 goto exit;
1235         }
1236         if (tlen+1 > CODA_MAXNAMLEN) {
1237                 MARK_INT_FAIL(CODA_RENAME_STATS);
1238                 error = EINVAL;
1239                 goto exit;
1240         }
1241         error = venus_rename(vtomi(odvp), &odcp->c_fid, &ndcp->c_fid, fnm,
1242             flen, tnm, tlen, cred, td->td_proc);
1243 exit:
1244         CODADEBUG(CODA_RENAME, myprintf(("in rename result %d\n",error)););
1245
1246         /*
1247          * Update namecache to reflect that the names of various objects may
1248          * have changed (or gone away entirely).
1249          */
1250         cache_purge(fvp);
1251         cache_purge(tvp);
1252
1253         /*
1254          * Release parents first, then children.
1255          */
1256         vrele(odvp);
1257         if (tvp) {
1258                 if (tvp == ndvp)
1259                         vrele(ndvp);
1260                 else
1261                         vput(ndvp);
1262                 vput(tvp);
1263         } else
1264                 vput(ndvp);
1265         vrele(fvp);
1266         return (error);
1267 }
1268
1269 int
1270 coda_mkdir(struct vop_mkdir_args *ap)
1271 {
1272         /* true args */
1273         struct vnode *dvp = ap->a_dvp;
1274         struct cnode *dcp = VTOC(dvp);
1275         struct componentname  *cnp = ap->a_cnp;
1276         struct vattr *va = ap->a_vap;
1277         struct vnode **vpp = ap->a_vpp;
1278         struct ucred *cred = cnp->cn_cred;
1279         struct thread *td = cnp->cn_thread;
1280         /* locals */
1281         int error;
1282         const char *nm = cnp->cn_nameptr;
1283         int len = cnp->cn_namelen;
1284         struct cnode *cp;
1285         CodaFid VFid;
1286         struct vattr ova;
1287
1288         MARK_ENTRY(CODA_MKDIR_STATS);
1289
1290         /*
1291          * Check for mkdir of target object.
1292          */
1293         if (IS_CTL_NAME(dvp, nm, len)) {
1294                 *vpp = (struct vnode *)0;
1295                 MARK_INT_FAIL(CODA_MKDIR_STATS);
1296                 return (EACCES);
1297         }
1298         if (len+1 > CODA_MAXNAMLEN) {
1299                 *vpp = (struct vnode *)0;
1300                 MARK_INT_FAIL(CODA_MKDIR_STATS);
1301                 return (EACCES);
1302         }
1303         error = venus_mkdir(vtomi(dvp), &dcp->c_fid, nm, len, va, cred,
1304             td->td_proc, &VFid, &ova);
1305         if (!error) {
1306                 if (coda_find(&VFid) != NULL)
1307                         panic("cnode existed for newly created directory!");
1308                 cp =  make_coda_node(&VFid, dvp->v_mount, va->va_type);
1309                 *vpp = CTOV(cp);
1310
1311                 /*
1312                  * Enter the new vnode in the Name Cache.
1313                  */
1314                 if (cnp->cn_flags & MAKEENTRY)
1315                         cache_enter(dvp, *vpp, cnp);
1316
1317                 /*
1318                  * Update the attr cache and mark as valid.
1319                  */
1320                 if (coda_attr_cache) {
1321                         VTOC(*vpp)->c_vattr = ova;
1322                         VTOC(*vpp)->c_flags |= C_VATTR;
1323                 }
1324
1325                 /*
1326                  * Invalidate the parent's attr cache, the modification time
1327                  * has changed.
1328                  */
1329                 VTOC(dvp)->c_flags &= ~C_VATTR;
1330                 vn_lock(*vpp, LK_EXCLUSIVE | LK_RETRY, td);
1331                 CODADEBUG( CODA_MKDIR, myprintf(("mkdir: %s result %d\n",
1332                     coda_f2s(&VFid), error)););
1333         } else {
1334                 *vpp = NULL;
1335                 CODADEBUG(CODA_MKDIR, myprintf(("mkdir error %d\n",error)););
1336         }
1337         return (error);
1338 }
1339
1340 int
1341 coda_rmdir(struct vop_rmdir_args *ap)
1342 {
1343         /* true args */
1344         struct vnode *vp = ap->a_vp;
1345         struct vnode *dvp = ap->a_dvp;
1346         struct cnode *dcp = VTOC(dvp);
1347         struct componentname  *cnp = ap->a_cnp;
1348         struct ucred *cred = cnp->cn_cred;
1349         struct thread *td = cnp->cn_thread;
1350         /* true args */
1351         int error;
1352         const char *nm = cnp->cn_nameptr;
1353         int len = cnp->cn_namelen;
1354 #if 0
1355         struct cnode *cp;
1356 #endif
1357
1358         MARK_ENTRY(CODA_RMDIR_STATS);
1359
1360         /*
1361          * Check for rmdir of control object.
1362          */
1363         if (IS_CTL_NAME(dvp, nm, len)) {
1364                 MARK_INT_FAIL(CODA_RMDIR_STATS);
1365                 return (ENOENT);
1366         }
1367
1368         /*
1369          * Possibly somewhat conservative purging, perhaps we just need to
1370          * purge vp?
1371          */
1372         cache_purge(dvp);
1373         cache_purge(vp);
1374
1375         /*
1376          * Invalidate the parent's attr cache, the modification time has
1377          * changed.
1378          */
1379         dcp->c_flags &= ~C_VATTR;
1380         error = venus_rmdir(vtomi(dvp), &dcp->c_fid, nm, len, cred,
1381             td->td_proc);
1382         CODADEBUG(CODA_RMDIR, myprintf(("in rmdir result %d\n", error)););
1383         return (error);
1384 }
1385
1386 int
1387 coda_symlink(struct vop_symlink_args *ap)
1388 {
1389         /* true args */
1390         struct vnode *tdvp = ap->a_dvp;
1391         struct cnode *tdcp = VTOC(tdvp);
1392         struct componentname *cnp = ap->a_cnp;
1393         struct vattr *tva = ap->a_vap;
1394         char *path = ap->a_target;
1395         struct ucred *cred = cnp->cn_cred;
1396         struct thread *td = cnp->cn_thread;
1397         struct vnode **vpp = ap->a_vpp;
1398         /* locals */
1399         int error;
1400
1401         /*-
1402          * XXX I'm assuming the following things about coda_symlink's
1403          * arguments:
1404          *       t(foo) is the new name/parent/etc being created.
1405          *       lname is the contents of the new symlink.
1406          */
1407         char *nm = cnp->cn_nameptr;
1408         int len = cnp->cn_namelen;
1409         int plen = strlen(path);
1410
1411         /*
1412          * Here's the strategy for the moment: perform the symlink, then do a
1413          * lookup to grab the resulting vnode.  I know this requires two
1414          * communications with Venus for a new sybolic link, but that's the
1415          * way the ball bounces.  I don't yet want to change the way the Mach
1416          * symlink works.  When Mach support is deprecated, we should change
1417          * symlink so that the common case returns the resultant vnode in a
1418          * vpp argument.
1419          */
1420         MARK_ENTRY(CODA_SYMLINK_STATS);
1421
1422         /*
1423          * Check for symlink of control object.
1424          */
1425         if (IS_CTL_NAME(tdvp, nm, len)) {
1426                 MARK_INT_FAIL(CODA_SYMLINK_STATS);
1427                 return (EACCES);
1428         }
1429         if (plen+1 > CODA_MAXPATHLEN) {
1430                 MARK_INT_FAIL(CODA_SYMLINK_STATS);
1431                 return (EINVAL);
1432         }
1433         if (len+1 > CODA_MAXNAMLEN) {
1434                 MARK_INT_FAIL(CODA_SYMLINK_STATS);
1435                 error = EINVAL;
1436                 goto exit;
1437         }
1438         error = venus_symlink(vtomi(tdvp), &tdcp->c_fid, path, plen, nm, len,
1439             tva, cred, td->td_proc);
1440
1441         /*
1442          * Invalidate the parent's attr cache, the modification time has
1443          * changed.
1444          */
1445         tdcp->c_flags &= ~C_VATTR;
1446         if (error == 0)
1447                 error = VOP_LOOKUP(tdvp, vpp, cnp);
1448 exit:
1449         CODADEBUG(CODA_SYMLINK, myprintf(("in symlink result %d\n",error)););
1450         return (error);
1451 }
1452
1453 /*
1454  * Read directory entries.
1455  *
1456  * XXX: This forwards the operator straight to the cache vnode using
1457  * VOP_READDIR(), rather than calling venus_readdir().  Why?
1458  */
1459 int
1460 coda_readdir(struct vop_readdir_args *ap)
1461 {
1462         /* true args */
1463         struct vnode *vp = ap->a_vp;
1464         struct cnode *cp = VTOC(vp);
1465         struct uio *uiop = ap->a_uio;
1466         struct ucred *cred = ap->a_cred;
1467         int *eofflag = ap->a_eofflag;
1468         u_long **cookies = ap->a_cookies;
1469         int *ncookies = ap->a_ncookies;
1470         struct thread *td = ap->a_uio->uio_td;
1471         /* upcall decl */
1472         /* locals */
1473         int error = 0;
1474         int opened_internally = 0;
1475
1476         MARK_ENTRY(CODA_READDIR_STATS);
1477         CODADEBUG(CODA_READDIR, myprintf(("coda_readdir(%p, %d, %lld, %d)\n",
1478             (void *)uiop->uio_iov->iov_base, uiop->uio_resid,
1479             (long long)uiop->uio_offset, uiop->uio_segflg)););
1480
1481         /*
1482          * Check for readdir of control object.
1483          */
1484         if (IS_CTL_VP(vp)) {
1485                 MARK_INT_FAIL(CODA_READDIR_STATS);
1486                 return (ENOENT);
1487         }
1488
1489         /*
1490          * If directory is not already open do an "internal open" on it.
1491          *
1492          * XXX: Why would this happen?  For files, there's memory mapping,
1493          * execution, and other kernel access paths such as ktrace.  For
1494          * directories, it is less clear.
1495          */
1496         if (cp->c_ovp == NULL) {
1497                 opened_internally = 1;
1498                 MARK_INT_GEN(CODA_OPEN_STATS);
1499                 error = VOP_OPEN(vp, FREAD, cred, td, NULL);
1500                 printf("coda_readdir: Internally Opening %p\n", vp);
1501                 if (error) {
1502                         printf("coda_readdir: VOP_OPEN on container failed "
1503                            "%d\n", error);
1504                         return (error);
1505                 }
1506         }
1507
1508         /*
1509          * Have UFS handle the call.
1510          */
1511         CODADEBUG(CODA_READDIR, myprintf(("indirect readdir: fid = %s, "
1512             "refcnt = %d\n", coda_f2s(&cp->c_fid), vp->v_usecount)););
1513         vn_lock(cp->c_ovp, LK_SHARED | LK_RETRY, td);
1514         error = VOP_READDIR(cp->c_ovp, uiop, cred, eofflag, ncookies,
1515             cookies);
1516         VOP_UNLOCK(cp->c_ovp, 0, td);
1517         if (error)
1518                 MARK_INT_FAIL(CODA_READDIR_STATS);
1519         else
1520                 MARK_INT_SAT(CODA_READDIR_STATS);
1521
1522         /*
1523          * Do an "internal close" if necessary.
1524          */
1525         if (opened_internally) {
1526                 MARK_INT_GEN(CODA_CLOSE_STATS);
1527                 (void)VOP_CLOSE(vp, FREAD, cred, td);
1528         }
1529         return (error);
1530 }
1531
1532 int
1533 coda_reclaim(struct vop_reclaim_args *ap)
1534 {
1535         /* true args */
1536         struct vnode *vp = ap->a_vp;
1537         struct cnode *cp = VTOC(vp);
1538         /* upcall decl */
1539         /* locals */
1540
1541         /*
1542          * Forced unmount/flush will let vnodes with non-zero use be
1543          * destroyed!
1544          */
1545         ENTRY;
1546
1547         if (IS_UNMOUNTING(cp)) {
1548 #ifdef  DEBUG
1549                 if (VTOC(vp)->c_ovp) {
1550                         if (IS_UNMOUNTING(cp))
1551                                 printf("coda_reclaim: c_ovp not void: vp "
1552                                     "%p, cp %p\n", vp, cp);
1553                 }
1554 #endif
1555         } else {
1556                 if (prtactive && vp->v_usecount != 0)
1557                         vprint("coda_reclaim: pushing active", vp);
1558         }
1559         cache_purge(vp);
1560         coda_free(VTOC(vp));
1561         vp->v_data = NULL;
1562         vp->v_object = NULL;
1563         return (0);
1564 }
1565
1566 int
1567 coda_lock(struct vop_lock1_args *ap)
1568 {
1569         /* true args */
1570         struct vnode *vp = ap->a_vp;
1571         struct cnode *cp = VTOC(vp);
1572         /* upcall decl */
1573         /* locals */
1574
1575         ENTRY;
1576         if ((ap->a_flags & LK_INTERLOCK) == 0) {
1577                 VI_LOCK(vp);
1578                 ap->a_flags |= LK_INTERLOCK;
1579         }
1580         if (coda_lockdebug)
1581                 myprintf(("Attempting lock on %s\n", coda_f2s(&cp->c_fid)));
1582         return (vop_stdlock(ap));
1583 }
1584
1585 int
1586 coda_unlock(struct vop_unlock_args *ap)
1587 {
1588         /* true args */
1589         struct vnode *vp = ap->a_vp;
1590         struct cnode *cp = VTOC(vp);
1591         /* upcall decl */
1592         /* locals */
1593
1594         ENTRY;
1595         if (coda_lockdebug)
1596                 myprintf(("Attempting unlock on %s\n",
1597                     coda_f2s(&cp->c_fid)));
1598         return (vop_stdunlock(ap));
1599 }
1600
1601 int
1602 coda_islocked(struct vop_islocked_args *ap)
1603 {
1604         /* true args */
1605
1606         ENTRY;
1607         return (vop_stdislocked(ap));
1608 }
1609
1610 static void
1611 coda_print_vattr(struct vattr *attr)
1612 {
1613         char *typestr;
1614
1615         switch (attr->va_type) {
1616         case VNON:
1617                 typestr = "VNON";
1618                 break;
1619
1620         case VREG:
1621                 typestr = "VREG";
1622                 break;
1623
1624         case VDIR:
1625                 typestr = "VDIR";
1626                 break;
1627
1628         case VBLK:
1629                 typestr = "VBLK";
1630                 break;
1631
1632         case VCHR:
1633                 typestr = "VCHR";
1634                 break;
1635
1636         case VLNK:
1637                 typestr = "VLNK";
1638                 break;
1639
1640         case VSOCK:
1641                 typestr = "VSCK";
1642                 break;
1643
1644         case VFIFO:
1645                 typestr = "VFFO";
1646                 break;
1647
1648         case VBAD:
1649                 typestr = "VBAD";
1650                 break;
1651
1652         default:
1653                 typestr = "????";
1654                 break;
1655         }
1656         myprintf(("attr: type %s mode %d uid %d gid %d fsid %d rdev %d\n",
1657             typestr, (int)attr->va_mode, (int)attr->va_uid,
1658             (int)attr->va_gid, (int)attr->va_fsid, (int)attr->va_rdev));
1659         myprintf(("      fileid %d nlink %d size %d blocksize %d bytes %d\n",
1660             (int)attr->va_fileid, (int)attr->va_nlink, (int)attr->va_size,
1661             (int)attr->va_blocksize,(int)attr->va_bytes));
1662         myprintf(("      gen %ld flags %ld vaflags %d\n", attr->va_gen,
1663             attr->va_flags, attr->va_vaflags));
1664         myprintf(("      atime sec %d nsec %d\n", (int)attr->va_atime.tv_sec,
1665             (int)attr->va_atime.tv_nsec));
1666         myprintf(("      mtime sec %d nsec %d\n", (int)attr->va_mtime.tv_sec,
1667             (int)attr->va_mtime.tv_nsec));
1668         myprintf(("      ctime sec %d nsec %d\n", (int)attr->va_ctime.tv_sec,
1669             (int)attr->va_ctime.tv_nsec));
1670 }
1671
1672 /*
1673  * How to print a ucred.
1674  */
1675 void
1676 coda_print_cred(struct ucred *cred)
1677 {
1678         int i;
1679
1680         myprintf(("ref %d\tuid %d\n",cred->cr_ref,cred->cr_uid));
1681         for (i=0; i < cred->cr_ngroups; i++)
1682                 myprintf(("\tgroup %d: (%d)\n",i,cred->cr_groups[i]));
1683         myprintf(("\n"));
1684 }
1685
1686 /*
1687  * Return a vnode for the given fid.  If no cnode exists for this fid create
1688  * one and put it in a table hashed by coda_f2i().  If the cnode for this fid
1689  * is already in the table return it (ref count is incremented by coda_find.
1690  * The cnode will be flushed from the table when coda_inactive calls
1691  * coda_unsave.
1692  */
1693 struct cnode *
1694 make_coda_node(CodaFid *fid, struct mount *vfsp, short type)
1695 {
1696         struct cnode *cp;
1697         struct vnode *vp;
1698         int err;
1699
1700         /*
1701          * XXXRW: This really needs a moderate amount of reworking.  We need
1702          * to properly tolerate failures of getnewvnode() and insmntque(),
1703          * and callers need to be able to accept an error back from
1704          * make_coda_node.  There may also be more general issues in how we
1705          * handle forced unmount.  Finally, if/when Coda loses its dependency
1706          * on Giant, the ordering of this needs rethinking.
1707          */
1708         cp = coda_find(fid);
1709         if (cp != NULL) {
1710                 vref(CTOV(cp));
1711                 return (cp);
1712         }
1713         cp = coda_alloc();
1714         cp->c_fid = *fid;
1715         err = getnewvnode("coda", vfsp, &coda_vnodeops, &vp);
1716         if (err)
1717                 panic("coda: getnewvnode returned error %d\n", err);
1718         vp->v_data = cp;
1719         vp->v_type = type;
1720         cp->c_vnode = vp;
1721         coda_save(cp);
1722         err = insmntque(vp, vfsp);
1723         if (err != 0)
1724                 printf("coda: insmntque failed: error %d", err);
1725         return (cp);
1726 }
1727
1728 int
1729 coda_pathconf(struct vop_pathconf_args *ap)
1730 {
1731
1732         switch (ap->a_name) {
1733         case _PC_NAME_MAX:
1734                 *ap->a_retval = CODA_MAXNAMLEN;
1735                 return (0);
1736
1737         case _PC_PATH_MAX:
1738                 *ap->a_retval = CODA_MAXPATHLEN;
1739                 return (0);
1740
1741         default:
1742                 return (vop_stdpathconf(ap));
1743         }
1744 }