text: /*-
   *             Coda: an Experimental Distributed File System
   *                              Release 3.1
   *
   *           Copyright (c) 1987-1998 Carnegie Mellon University
   *                          All Rights Reserved
   *
   * Permission  to  use, copy, modify and distribute this software and its
   * documentation is hereby granted,  provided  that  both  the  copyright
   * notice  and  this  permission  notice  appear  in  all  copies  of the
   * software, derivative works or  modified  versions,  and  any  portions
   * thereof, and that both notices appear in supporting documentation, and
   * that credit is given to Carnegie Mellon University  in  all  documents
   * and publicity pertaining to direct or indirect use of this code or its
   * derivatives.
   *
   * CODA IS AN EXPERIMENTAL SOFTWARE SYSTEM AND IS  KNOWN  TO  HAVE  BUGS,
   * SOME  OF  WHICH MAY HAVE SERIOUS CONSEQUENCES.  CARNEGIE MELLON ALLOWS
   * FREE USE OF THIS SOFTWARE IN ITS "AS IS" CONDITION.   CARNEGIE  MELLON
   * DISCLAIMS  ANY  LIABILITY  OF  ANY  KIND  FOR  ANY  DAMAGES WHATSOEVER
   * RESULTING DIRECTLY OR INDIRECTLY FROM THE USE OF THIS SOFTWARE  OR  OF
   * ANY DERIVATIVE WORK.
   *
   * Carnegie  Mellon  encourages  users  of  this  software  to return any
   * improvements or extensions that  they  make,  and  to  grant  Carnegie
   * Mellon the rights to redistribute these changes without encumbrance.
   *
   * 	@(#) src/sys/coda/coda_subr.c,v 1.1.1.1 1998/08/29 21:14:52 rvb Exp $
   */
  
  /*-
   * Mach Operating System
   * Copyright (c) 1989 Carnegie-Mellon University
   * All rights reserved.  The CMU software License Agreement specifies
   * the terms and conditions for use and redistribution.
   */
  
  /*
   * This code was written for the Coda filesystem at Carnegie Mellon
   * University.  Contributers include David Steere, James Kistler, and
   * M. Satyanarayanan.
   */
  
  /*-
   * NOTES: rvb
   * 1.	Added coda_unmounting to mark all cnodes as being UNMOUNTING.  This
   *	has to be done before dounmount is called.  Because some of the
   *	routines that dounmount calls before coda_unmounted might try to
   *	force flushes to venus.  The vnode pager does this.
   * 2.	coda_unmounting marks all cnodes scanning coda_cache.
   * 3.	cfs_checkunmounting (under DEBUG) checks all cnodes by chasing the
   *	vnodes under the /coda mount point.
   * 4.	coda_cacheprint (under DEBUG) prints names with vnode/cnode address.
   */
  
  #include <sys/cdefs.h>
  __FBSDID("$FreeBSD: releng/9.3/sys/fs/coda/coda_subr.c 244658 2012-12-24 13:22:32Z kib $");
  
  #include <sys/param.h>
  #include <sys/systm.h>
  #include <sys/lock.h>
  #include <sys/malloc.h>
  #include <sys/mutex.h>
  #include <sys/mount.h>
  
  #include <fs/coda/coda.h>
  #include <fs/coda/cnode.h>
  #include <fs/coda/coda_subr.h>
  
  static int coda_active = 0;
  static int coda_reuse = 0;
  static int coda_new = 0;
  
  static struct cnode *coda_freelist = NULL;
  static struct cnode *coda_cache[CODA_CACHESIZE];
  
  #define	CNODE_NEXT(cp)	((cp)->c_next)
  
  #ifdef CODA_COMPAT_5
  #define	coda_hash(fid)	(((fid)->Volume + (fid)->Vnode) & (CODA_CACHESIZE-1))
  #define	IS_DIR(cnode)	(cnode.Vnode & 0x1)
  #else
  #define	coda_hash(fid)	(coda_f2i(fid) & (CODA_CACHESIZE-1))
  #define	IS_DIR(cnode)	(cnode.opaque[2] & 0x1)
  #endif
  
  /*
   * Allocate a cnode.
   */
  struct cnode *
  coda_alloc(void)
  {
  	struct cnode *cp;
  
  	if (coda_freelist != NULL) {
  		cp = coda_freelist;
  		coda_freelist = CNODE_NEXT(cp);
  		coda_reuse++;
  	} else {
  		CODA_ALLOC(cp, struct cnode *, sizeof(struct cnode));
  
  		/*
  		 * FreeBSD vnodes don't have any Pager info in them ('cause
  		 * there are no external pagers, duh!).
  		 */
  #define	VNODE_VM_INFO_INIT(vp)         /* MT */
  		VNODE_VM_INFO_INIT(CTOV(cp));
  		coda_new++;
  	}
  	bzero(cp, sizeof (struct cnode));
  	return (cp);
  }
  
  /*
   * Deallocate a cnode.
   */
  void
  coda_free(struct cnode *cp)
  {
  
  	CNODE_NEXT(cp) = coda_freelist;
  	coda_freelist = cp;
  }
  
  /*
   * Put a cnode in the hash table.
   */
  void
  coda_save(struct cnode *cp)
  {
  
  	CNODE_NEXT(cp) = coda_cache[coda_hash(&cp->c_fid)];
  	coda_cache[coda_hash(&cp->c_fid)] = cp;
  }
  
  /*
   * Remove a cnode from the hash table.
   */
  void
  coda_unsave(struct cnode *cp)
  {
  	struct cnode *ptr;
  	struct cnode *ptrprev = NULL;
  
  	ptr = coda_cache[coda_hash(&cp->c_fid)];
  	while (ptr != NULL) {
  		if (ptr == cp) {
  			if (ptrprev == NULL)
  				coda_cache[coda_hash(&cp->c_fid)] =
  				    CNODE_NEXT(ptr);
  	    		else
  				CNODE_NEXT(ptrprev) = CNODE_NEXT(ptr);
  			CNODE_NEXT(cp) = (struct cnode *)NULL;
  			return;
  		}
  		ptrprev = ptr;
  		ptr = CNODE_NEXT(ptr);
  	}
  }
  
  /*
   * Lookup a cnode by fid. If the cnode is dying, it is bogus so skip it.
   *
   * NOTE: this allows multiple cnodes with same fid -- dcs 1/25/95
   */
  struct cnode *
  coda_find(struct CodaFid *fid)
  {
  	struct cnode *cp;
  
  	cp = coda_cache[coda_hash(fid)];
  	while (cp) {
  		if (coda_fid_eq(&(cp->c_fid), fid) && (!IS_UNMOUNTING(cp))) {
  			coda_active++;
  			return (cp);
  		}
  		cp = CNODE_NEXT(cp);
  	}
  	return (NULL);
  }
  
  /*
   * Clear all cached access control decisions from Coda.
   */
  static void
  coda_acccache_purge(struct mount *mnt)
  {
  	struct cnode *cp;
  	int hash;
  
  	for (hash = 0; hash < CODA_CACHESIZE; hash++) {
  		for (cp = coda_cache[hash]; cp != NULL;
  		    cp = CNODE_NEXT(cp)) {
  			if (CTOV(cp)->v_mount == mnt && VALID_ACCCACHE(cp)) {
  				CODADEBUG(CODA_FLUSH, myprintf(("acccache "
  				    "purge fid %s uid %d mode 0x%x\n",
  				    coda_f2s(&cp->c_fid), cp->c_cached_uid,
  				    (int)cp->c_cached_mode)););
  				cp->c_flags &= ~C_ACCCACHE;
  			}
  		}
  	}
  }
  
  /*
   * When a user loses their tokens (or other related events), we invalidate
   * any cached access rights in the access cache.  In the Linux version of
   * Coda, we maintain a global epoch and simply bump it to invalidate all
   * cached results generated in the epoch.  For now, we walk all cnodes and
   * manually invalidate just that uid in FreeBSD.
   */
  static void
  coda_acccache_purgeuser(struct mount *mnt, uid_t uid)
  {
  	struct cnode *cp;
  	int hash;
  
  	for (hash = 0; hash < CODA_CACHESIZE; hash++) {
  		for (cp = coda_cache[hash]; cp != NULL;
  		    cp = CNODE_NEXT(cp)) {
  			if (CTOV(cp)->v_mount == mnt &&
  			    VALID_ACCCACHE(cp) && (cp->c_cached_uid == uid)) {
  				CODADEBUG(CODA_PURGEUSER, myprintf((
  				    "acccache purgeuser fid %s uid %d mode "
  				    "0x%x\n", coda_f2s(&cp->c_fid),
  				    cp->c_cached_uid, (int)cp->c_cached_mode)););
  				cp->c_flags &= ~C_ACCCACHE;
  			}
  		}
  	}
  }
  
  /*
   * coda_kill is called as a side effect to vcopen.  To prevent any cnodes
   * left around from an earlier run of a venus or warden from causing problems
   * with the new instance, mark any outstanding cnodes as dying.  Future
   * operations on these cnodes should fail (excepting coda_inactive of
   * course!).  Since multiple venii/wardens can be running, only kill the
   * cnodes for a particular entry in the coda_mnttbl. -- DCS 12/1/94
   *
   * XXX: I don't believe any special behavior is required with respect to the
   * global namecache here, as /coda will have unmounted and hence cache_flush
   * will have run...?
   */
  int
  coda_kill(struct mount *whoIam, enum dc_status dcstat)
  {
  	int hash, count = 0;
  	struct cnode *cp;
  
  	/*-
  	 * Algorithm is as follows:
  	 *     Second, flush whatever vnodes we can from the name cache.
  	 *
  	 *     Finally, step through whatever is left and mark them dying.
  	 *        This prevents any operation at all.
  	 *
  	 * This is slightly overkill, but should work.  Eventually it'd be
  	 * nice to only flush those entries from the namecache that reference
  	 * a vnode in this vfs.
  	 *
  	 * XXXRW: Perhaps we no longer need to purge the name cache when
  	 * using the VFS name cache, as unmount will do that.
  	 */
  	cache_purgevfs(whoIam);
  	for (hash = 0; hash < CODA_CACHESIZE; hash++) {
  		for (cp = coda_cache[hash];cp != NULL;
  		    cp = CNODE_NEXT(cp)) {
  			if (CTOV(cp)->v_mount == whoIam) {
  #ifdef DEBUG
  				printf("coda_kill: vp %p, cp %p\n", CTOV(cp),
  				    cp);
  #endif
  				count++;
  				CODADEBUG(CODA_FLUSH, myprintf(("Live cnode "
  				    "fid %s flags %d count %d\n",
  				    coda_f2s(&cp->c_fid), cp->c_flags,
  				    vrefcnt(CTOV(cp)))););
  			}
  		}
  	}
  	return (count);
  }
  
  /*
   * There are two reasons why a cnode may be in use, it may be in the name
   * cache or it may be executing.
   */
  void
  coda_flush(struct coda_mntinfo *mnt, enum dc_status dcstat)
  {
  	int hash;
  	struct cnode *cp;
  
  	coda_clstat.ncalls++;
  	coda_clstat.reqs[CODA_FLUSH]++;
  
  	coda_acccache_purge(mnt->mi_vfsp);
  	cache_purgevfs(mnt->mi_vfsp);
  	for (hash = 0; hash < CODA_CACHESIZE; hash++) {
  		for (cp = coda_cache[hash]; cp != NULL;
  		    cp = CNODE_NEXT(cp)) {
  			/*
  			 * Only files that can be executed need to be flushed
  			 * from the VM.
  			 *
  			 * NOTE: Currently this doesn't do anything, but
  			 * perhaps it should?
  			 */
  			if (!IS_DIR(cp->c_fid))
  				coda_vmflush(cp);
  		}
  	}
  }
  
  /*
   * As a debugging measure, print out any cnodes that lived through a name
   * cache flush.
   */
  void
  coda_testflush(void)
  {
  	int hash;
  	struct cnode *cp;
  
  	for (hash = 0; hash < CODA_CACHESIZE; hash++) {
  		for (cp = coda_cache[hash]; cp != NULL;
  		    cp = CNODE_NEXT(cp))
  			myprintf(("Live cnode fid %s count %d\n",
  			    coda_f2s(&cp->c_fid), CTOV(cp)->v_usecount));
  	}
  }
  
  /*
   * First, step through all cnodes and mark them unmounting.  FreeBSD kernels
   * may try to fsync them now that venus is dead, which would be a bad thing.
   */
  void
  coda_unmounting(struct mount *whoIam)
  {
  	int hash;
  	struct cnode *cp;
  
  	for (hash = 0; hash < CODA_CACHESIZE; hash++) {
  		for (cp = coda_cache[hash]; cp != NULL;
  		    cp = CNODE_NEXT(cp)) {
  			if (CTOV(cp)->v_mount == whoIam) {
  				if (cp->c_flags & (C_LOCKED|C_WANTED)) {
  					printf("coda_unmounting: Unlocking "
  					    "%p\n", cp);
  					cp->c_flags &= ~(C_LOCKED|C_WANTED);
  					wakeup((caddr_t) cp);
  				}
  				cp->c_flags |= C_UNMOUNTING;
  			}
  		}
  	}
  }
  
  #ifdef DEBUG
  void
  coda_checkunmounting(struct mount *mp)
  {
  	struct vnode *vp, *nvp;
  	struct cnode *cp;
  	int count = 0, bad = 0;
  
  	MNT_VNODE_FOREACH_ALL(vp, mp, nvp) {
  		cp = VTOC(vp);
  		count++;
  		if (!(cp->c_flags & C_UNMOUNTING)) {
  			bad++;
  			printf("vp %p, cp %p missed\n", vp, cp);
  			cp->c_flags |= C_UNMOUNTING;
  		}
  		VI_UNLOCK(vp);
  	}
  }
  
  void
  coda_cacheprint(struct mount *whoIam)
  {
  	int hash;
  	struct cnode *cp;
  	int count = 0;
  
  	printf("coda_cacheprint: coda_ctlvp %p, cp %p", coda_ctlvp,
  	    VTOC(coda_ctlvp));
  
  #if 0
  	coda_nc_name(VTOC(coda_ctlvp));
  #endif
  	printf("\n");
  	for (hash = 0; hash < CODA_CACHESIZE; hash++) {
  		for (cp = coda_cache[hash]; cp != NULL;
  		    cp = CNODE_NEXT(cp)) {
  			if (CTOV(cp)->v_mount == whoIam) {
  				printf("coda_cacheprint: vp %p, cp %p",
  				    CTOV(cp), cp);
  #if 0
  				coda_nc_name(cp);
  #endif
  				printf("\n");
  				count++;
  			}
  		}
  	}
  	printf("coda_cacheprint: count %d\n", count);
  }
  #endif
  
  /*-
   * There are 6 cases where invalidations occur.  The semantics of each is
   * listed here:
   *
   * CODA_FLUSH     -- Flush all entries from the name cache and the cnode
   *                   cache.
   *
   * CODA_PURGEUSER -- Flush all entries from the name cache for a specific
   *                   user.   This call is a result of token expiration.
   *
   * The next two are the result of callbacks on a file or directory:
   *
   * CODA_ZAPDIR    -- Flush the attributes for the dir from its cnode.  Zap
   *                   all children of this directory from the namecache.
   *
   * CODA_ZAPFILE   -- Flush the attributes for a file.
   *
   * The fifth is a result of Venus detecting an inconsistent file:
   *
   * CODA_PURGEFID  -- Flush the attribute for the file; if it is a dir (odd
   *                   vnode), purge its children from the namecache; remove
   *                   the file from the namecache.
   *
   * The sixth allows Venus to replace local fids with global ones during
   * reintegration.
   *
   * CODA_REPLACE   -- Replace one CodaFid with another throughout the name
   *                   cache.
   */
  int
  handleDownCall(struct coda_mntinfo *mnt, int opcode, union outputArgs *out)
  {
  	int error;
  
  	/*
  	 * Handle invalidate requests.
  	 */
  	switch (opcode) {
  	case CODA_FLUSH: {
  		coda_flush(mnt, IS_DOWNCALL);
  
  		/* Print any remaining cnodes. */
  		CODADEBUG(CODA_FLUSH, coda_testflush(););
  		return (0);
  	}
  
  	case CODA_PURGEUSER: {
  		coda_clstat.ncalls++;
  		coda_clstat.reqs[CODA_PURGEUSER]++;
  
  		/* XXX - need to prevent fsync's. */
  
  		/*
  		 * Purge any access cache entries for the uid.
  		 */
  #ifdef CODA_COMPAT_5
  	  	coda_acccache_purgeuser(mnt->mi_vfsp,
  		    out->coda_purgeuser.cred.cr_uid);
  #else
  		coda_acccache_purgeuser(mnt->mi_vfsp,
  		    out->coda_purgeuser.uid);
  #endif
  		return (0);
  	}
  
  	case CODA_ZAPFILE: {
  		struct cnode *cp;
  
  		error = 0;
  		coda_clstat.ncalls++;
  		coda_clstat.reqs[CODA_ZAPFILE]++;
  		cp = coda_find(&out->coda_zapfile.Fid);
  		if (cp != NULL) {
  			vref(CTOV(cp));
  			cache_purge(CTOV(cp));
  			cp->c_flags &= ~(C_VATTR | C_ACCCACHE);
  			ASSERT_VOP_LOCKED(CTOV(cp), "coda HandleDownCall");
  			if (VOP_IS_TEXT(CTOV(cp)))
  				error = coda_vmflush(cp);
  			CODADEBUG(CODA_ZAPFILE,
  			myprintf(("zapfile: fid = %s, refcnt = %d, error = "
  			    "%d\n", coda_f2s(&cp->c_fid),
  			    CTOV(cp)->v_usecount - 1, error)););
  			if (vrefcnt(CTOV(cp)) == 1)
  				cp->c_flags |= C_PURGING;
  			vrele(CTOV(cp));
  		}
  		return (error);
        }
  
        case CODA_ZAPDIR: {
  		struct cnode *cp;
  
  		coda_clstat.ncalls++;
  		coda_clstat.reqs[CODA_ZAPDIR]++;
  		cp = coda_find(&out->coda_zapdir.Fid);
  		if (cp != NULL) {
  			vref(CTOV(cp));
  			cache_purge(CTOV(cp));
  			cp->c_flags &= ~(C_VATTR | C_ACCCACHE);
  			CODADEBUG(CODA_ZAPDIR, myprintf(("zapdir: fid = %s, "
  			    "refcnt = %d\n", coda_f2s(&cp->c_fid),
  			    CTOV(cp)->v_usecount - 1)););
  			if (vrefcnt(CTOV(cp)) == 1)
  				cp->c_flags |= C_PURGING;
  			vrele(CTOV(cp));
  		}
  		return (0);
        }
  
        case CODA_PURGEFID: {
  		struct cnode *cp;
  
  		error = 0;
  		coda_clstat.ncalls++;
  		coda_clstat.reqs[CODA_PURGEFID]++;
  		cp = coda_find(&out->coda_purgefid.Fid);
  		if (cp != NULL) {
  			vref(CTOV(cp));
  			cache_purge(CTOV(cp));
  			cp->c_flags &= ~(C_VATTR | C_ACCCACHE);
  			ASSERT_VOP_LOCKED(CTOV(cp), "coda HandleDownCall");
  			if (!(IS_DIR(out->coda_purgefid.Fid))
  			    && VOP_IS_TEXT(CTOV(cp)))
  				error = coda_vmflush(cp);
  			CODADEBUG(CODA_PURGEFID, myprintf(("purgefid: fid "
  			    "= %s, refcnt = %d, error = %d\n",
  			    coda_f2s(&cp->c_fid),
  			    CTOV(cp)->v_usecount - 1, error)););
  			if (vrefcnt(CTOV(cp)) == 1)
  				cp->c_flags |= C_PURGING;
  			vrele(CTOV(cp));
  		}
  		return (error);
  	}
  
  	case CODA_REPLACE: {
  		struct cnode *cp = NULL;
  
  		coda_clstat.ncalls++;
  		coda_clstat.reqs[CODA_REPLACE]++;
  		cp = coda_find(&out->coda_replace.OldFid);
  		if (cp != NULL) {
  			/*
  			 * Remove the cnode from the hash table, replace the
  			 * fid, and reinsert.  Clear the attribute cache as
  			 * the "inode number" may have changed (it's just a
  			 * hash of the fid, and the fid is changing).
  			 */
  			vref(CTOV(cp));
  			coda_unsave(cp);
  			cp->c_fid = out->coda_replace.NewFid;
  			cp->c_flags &= ~C_VATTR;
  			coda_save(cp);
  			CODADEBUG(CODA_REPLACE, myprintf(("replace: oldfid "
  			    "= %s, newfid = %s, cp = %p\n",
  			    coda_f2s(&out->coda_replace.OldFid),
  			    coda_f2s(&cp->c_fid), cp)););
  			vrele(CTOV(cp));
  	  	}
  		return (0);
  	}
  	default:
  		myprintf(("handleDownCall: unknown opcode %d\n", opcode));
  		return (EINVAL);
  	}
  }
  
  int
  coda_vmflush(struct cnode *cp)
  {
  
  	return (0);
  }
  
  /*
   * Kernel-internal debugging switches.
   */
  void
  coda_debugon(void)
  {
  
  	codadebug = -1;
  	coda_vnop_print_entry = 1;
  	coda_psdev_print_entry = 1;
  	coda_vfsop_print_entry = 1;
  }
  
  void
  coda_debugoff(void)
  {
  
  	codadebug = 0;
  	coda_vnop_print_entry = 0;
  	coda_psdev_print_entry = 0;
  	coda_vfsop_print_entry = 0;
  }
  
  /*-
   * Utilities used by both client and server
   * Standard levels:
   * 0) no debugging
   * 1) hard failures
   * 2) soft failures
   * 3) current test software
   * 4) main procedure entry points
   * 5) main procedure exit points
   * 6) utility procedure entry points
   * 7) utility procedure exit points
   * 8) obscure procedure entry points
   * 9) obscure procedure exit points
   * 10) random stuff
   * 11) all <= 1
   * 12) all <= 2
   * 13) all <= 3
   * ...
   */
  